Tooling for a persistent, cross-branch patch series?

[stdedos]

Hello there!

A problem I face all too often:

1. I come up with a useful idea
2. I implement it
3. I propose it upstream
4. It gets declined (fair!)

Thing is, I still need that functionality. For instance, gem 'ricecream' is super helpful in my day-to-day.

Forking isn't really an option - I need to stay close to upstream.
For smaller projects, I keep patches on my master and clean them up before contributing. But in branch-heavy workflows, that gets unmanageable quickly.

I've looked into https://gitbutler.com/ - too heavy and slow, weird branches.
stg sounds promising, but stg init is per-branch, and I need something cross-cutting.

What I really want:

• A persistent patch series, like a "one true patchset"
• It should rebase cleanly, git pull --rebase --autostash-style
• Ideally, I could snapshot it (e.g., OTPS/before-big-bang) and revisit it later (e.g. when developing for an maintenance version)
  • I am fine "fixing it now" and "throwing it away" later

Does such tooling or workflow exist?
Thanks for reading - I appreciate any tips or experiences shared 🌟🌟🌟

[lkraav]

Yeah I think I could use something like this to keep certain Docker Mongo volumes static instead of anonymous aross branches.

[NonLogicalDev]

Out of curiosity what would you describe as persistent patch series?
Technically with stg you can already reference other branches if you want to copy them from one branch to the current one.

Alternatively you can set up a branch hierarchy in your repo:

origin/main
  \ - proxy_branch (branch with your modifications)
    \- your_feature_1
    \- your_feature_2

You can do this via:

git clone $URL $DIR
cd $DIR

git branch proxy_branch --set-upstream origin/main origin/main
<this can have stg stack on it>

git branch your_feature_1 --set-upstream proxy_branch proxy_branch
git checkout your_feature_1
< develop here >

git branch your_feature_2 --set-upstream proxy_branch proxy_branch
git checkout your_feature_2
< develop here >

git checkout proxy_branch
<make changes here when needed or when rebasing>
stg pull -m # will pull changes from upstream (origin/main)

git checkout your_feature_1
stg pull -m # will pull change from upstrea (proxy_branch: your local one you just updated)

As long as you remember to do this recursive pull every now and then and basing all your local work off of proxy_branch, you effectively have the global patch list.

If you want to open source / contribute (say your_feature_1)

git checkout your_feature_1
git branch --set-upstream origin/main
stg pull -m

<you are ready to push the changeset to github>

git branch --set-upstream proxy_branch
stg pull -m

<you are ready to develop with all your local helpers>