cherrypick | Spearmint benchmarks are in the spearmint folder | Incremental Backup library

• resolve conflict steps:

1. edit source file, resolve conflict
2. git add resolved files.
3. git commit .
4. git push to remote repo

You're really overcomplicating this. Just double the substring and check if that appears in the string.

I would recommend you:

• checkout to you desired ancestral,
• cherry-pick your change,
• test you change/solve any merge conflict (if any)
• commit-ammend*
• finally, push

*I'm considering you commit has a gerrit's Change-Id; if doesn't, you should do a regular commit to create it (the commit-msg hook is responsible by that).

Also, when I say push, I'm referring to gerrit's approach (which is a git push origin HEAD:refs/for/master not simply git push).

From https://git-scm.com/docs/git-cherry-pick

First, let's get pull out of the question, because pulling is a red herring: git pull means, roughly speaking, run git fetch, then run git merge. The action you're concerned with here is merging.

Update It is appearing unlikely that git supports something like this directly. I am looking into a mixed approach of cherrypicking individual files via a script that looks for new and modified entries only.

Let's go back to the basics: Git implements version control by making full snapshots of every file. These are in commits. Commits are numbered, with big ugly hash IDs. Each commit has two parts: the snapshot, and some metadata. The metadata shows who made the commit, when, and so on, and contains the number(s) of its parent commits.

Now look at your question again: you want new files and modified files. A commit, standing by itself, has no new files. It has no modified files. It has no deleted files. It just has files: it is simply a snapshot. You find something to be "new" or "modified" by comparing the snapshot to some other snapshot.

Which snapshot shall we compare, to which other snapshot? That's the key to solving your problem: you must pick the right set of snapshots and direct Git to do the right comparisons. Do you want one single comparison? Do you want many comparisons? Which ones do you want done, when, and what do you want to do with each comparison's result?

Realizing this, and looking at how git merge itself operates, will tell you whether git merge can be helpful. Knowing this, and looking at how git cherry-pick works, will tell you whether git cherry-pick can be helpful. Or, perhaps you should simply write your own tool—a script that invokes various Git plumbing commands¹ that will do what you want done.

¹Git divides its commands into porcelain or user-facing commands, vs plumbing commands. These are typically tools to do some specific job, but porcelain commands typically offer both options and user configuration. For instance, git pull runs two Git commands, but some users want the second command to be git rebase instead of git merge, so you can configure git pull to run git rebase instead of git merge. That in turn means that if you are 100% sure you want, in some script, to run git fetch followed by git merge, you should not use git pull because it might run git rebase instead!

Git's attempt to divide these is not completely successful, but some commands, such as git for-each-ref and git rev-list, are definitely not end-user-oriented, while others like git log and git diff are, or try to be. The git diff command has multiple plumbing commands that implement various parts: git diff-index, git diff-tree, git diff-files. None of those read user configuration. The git diff porcelain command does read user configuration. So in a script, you would generally want to figure out which plumbing command to use, so as not to have your script break due to user configuration.

Merge is a big and complicated command, but if we ignore various options, such as --squash, and edge cases such as when git merge does a fast-forward instead of merging, it ends up being relatively simple for most cases:

• The merge operation takes two commits: the current commit, at the tip of the current branch, and some other commit, at the tip of some other branch.

• Merge uses the commit graph to identify a merge base commit. This is the best common commit: of all the commits that are on both branches, one of them is "best". (Technically this is the Lowest Common Ancestor of the DAG formed by the commits' parent/child relationships in the commit graph.)

• Merge now performs not one but two diffs. The two diffs compare the common ancestor—the merge base—to each of the two branch tip commits:

You are checking out a remote branch (origin/whatever). Git is more than happy to comply but a local branch is not created at that point... you are left in detached HEAD state.... and then you run your magic and do git push origin HEAD and I think your are missing the target branch. Is it rather git push origin HEAD:$2? Finally, do not trust std or err output to tell if the operation went well or not. Use the exit code of the execution to know if it was ok (0 = ok. Anything not 0 = not ok).

Find the merge-base of C and B.

I think you forgot to start a php tag which means one of your { brackets is in the javascript string and not in php. Due to that, the closing bracket } of is is unexpected because it never started.

Try adding a on the first line where I created the arrow on your screenshot:

Just run git merge hash-of-desired-commit.

In fact, this is how git merge actually works. Git does not merge based on branches,¹ but rather based on commits. When you run git merge branch-name, Git turns the name into a commit hash, and then does the merge with the hash. The only thing that the name does is set the default commit message (to, e.g., merge branch br or merge branch br into feature).

¹To be more precise, what I mean here is branch names. See also What exactly do we mean by "branch"? When you specify a commit hash, the resulting merge contains a subset of the commit graph, and the word branch also means some subset of a commit graph, so in that sense, Git does merge "branches".

The problem here is that the word branch itself is overused, which drains it of meaning. Have you ever been to a party where everyone is named Bruce? "Hey, Bruce! Bruce told me to tell you that Bruce called Bruce to relay that Bruce wasn't going to be able to make it. Please tell this to Bruce, OK?" (Which Bruce is actually not going to make it?)