On 09/04/2019 09:21, Bartosz Dziewoński wrote:
Hopefully this will not stay disabled forever, for I
also miss the
feature.
In the meantime, you can use the traditional Git way of generating
patch files and sending them by email (or perhaps, in a modern twist,
via Phabricator).
To generate a patch file of the most recent commit:
git format-patch -1
(that's 'dash one', and it's critical, because otherwise Git will
generate patch files for ALL commits)
Then upload the generated file to Phabricator or something.
To apply such a patch file and turn it into a commit:
git am foo.patch
There are some other options for dealing with multiple dependent
commits, if you ever need them.
The problem is I'm going to need to do that for like one in every five
commits, and often for multiple patches in a set. And... yes, we /do/
wind up with multiple dependent commits at times.
To explain why this comes up so much for me: I am a UX designer. I'm not
much of a dev. Most of what I do is describe generally what I want and
then throw it at someone else, and they implement the actual logic, but
then they pass it back to me to fill in the rest of the interaction
stuff, because not only would it be incredibly tedious for me to try to
explain every possible combination users might run into, it probably
wouldn't even work. Without the code in front of me, without testing it
and playing through each use case to ensure it actually results in the
expected behaviour, I am going to miss things.
While it does work in some cases to simply have the logic in one patch
and the interaction in another, much of what we work on is considered
stable, where we should not be merging half-complete patches unless we
absolutely must.
(Note too that this is specifically /my/ use case - this isn't even
getting into issues with minor changes that are easier to apply than to
explain, especially when helping newcomers through where it'd be
needlessly frustrating for them to implement a bunch of minor fixes when
the core of their patch is in fact good; or when just dealing with
typos; or when restoring someone's five-year-old abandoned patch because
wait, we actually do need that now; or...)
Should we just, uh, not be using gerrit, or something? Because that's
just... complicated.
-I