git cherry-pick to another branch

Question

I wonder if there is the way to copy one commit to another branch without checking out that branch.

For example, I have two branches: master and parallel_version.

I'm on parallel_version branch and I found a bug in file common for these branches.

I've fixed it and committed. How to duplicate this commit to another branch, assuming I'm using git-svn?

Normally I would do:

$ git checkout master
$ git cherry-pick parallel_version
$ git checkout parallel_version

Is there better way of doing that?

Vyse

Answer 1

That's not possible - simply imagine what would happen if there was a conflict that couldn't be resolved automatically. For the same reason you also can't update branches that are not currently checked-out (even if a fast-forward was possible).

Laquanda

You can update other branch with: git fetch origin & git branch mybranch origin/mybranch -f – Mcgaw

@Mcgaw Even simpler: git fetch <remote> <branch>:<branch> – Laid

"Not possible in the current implementation", yes. "Not worth the trouble to implement it properly" - maybe. But a potentially unresolvable conflict is not a good argument for that: in that case the cherry-pick should fail without making changes to working dir or repo state. – Semang

"For the same reason you also can't update branches that are not currently checked-out (even if a fast-forward was possible)." This sentence is false: https://mcmap.net/q/53589/-merge-update-and-pull-git-branches-without-using-checkouts – Infliction

Answer 2

https://github.com/lennartcl/gitl provides "git cherry-copy" and "git cherry-move" scripts that do this and handle most of the corner cases.

Chalmer

Looks like "git cherry-copy" just automates the 3 manual steps outlined by the OP. Thus, it does not contradict @ThiefMaster. I was hoping to cherry-copy a commit to branch "later" while compiling the current branch. That didn't go well… – Amoretto

Answer 3

Here's a small script that creates a temporary clone of the repository, as suggested by user2394284:

_{/usr/bin/git-tmp-clone or ~/bin/git-tmp-clone}

#!/bin/bash

gitTopLevel=$(git rev-parse --show-toplevel)

# Unique name for the temporary clone.
totalhash=$(tar -c "$gitTopLevel/.git" 2> /dev/null | sha256sum | head -c8)

tmprepo="/tmp/$(basename $(pwd))_${totalhash}"

git clone "$gitTopLevel" ${tmprepo}

# Start an interactive shell in the clone. Pass any
# arguments as initial commands to be executed.
/bin/bash --init-file <(echo "cd ${tmprepo}; $@")

# Clean up the clone.
rm -rf ${tmprepo} && echo "Deleted ${tmprepo}"

(This script is less than robust, but it seems to work for me on Ubuntu.)

You can use this to cherry-pick e.g. the last commit on the current brach to another branch, by running

git-tmp-clone "git checkout TARGET_BRANCH
            && git cherry-pick $(git rev-parse --short @)
            && git push origin HEAD"

(Note that in this example, the rev-parse is evaluated in the origin repository before the clone is created! That's why it points to the most recent commit. Adapt as needed.)

Soper

Answer 4

Crazy idea (based on mnaoumov's comment) if you really want to avoid touching the checked out files (say you don't want to disturb your build system) … that's what I want anyway.

1. Clone the whole git repo to a temporary directory.
2. Do the work in the clone.
3. Add the clone as a remote.
4. git fetch clone && git branch mybranch clone/mybranch -f
5. Clean up.

This would be a thing to automate. If you have filesystem snapshots, cloning the whole repo is cheap – perhaps not so crazy after all…

Amoretto

In that case it is better to use git worktree instead of clone. It won't copy whole .git – Vyse

That's actually a good hack. The inefficiency shouldn't matter for small-ish projects. – Soper

Instead of adding the tmp clone as a remote, you could just push from the clone to its origin – FFD-pushing to a not-checked-out branch on a remote is after all no problem. – Soper