squash | Compression abstraction library and utilities

To overwrite local history with remote history, will remove all files, where are only on local history. So be carefully!

Is it by design?

Yes, git does not instantly delete objects once they are not referenced. This may be done eventually by the GC (git gc). Not instantly removing such references makes it easy for you to recover lost data using git reflog (as long as you have added/committed the data previously).

How do we call this kind of "orphan" commits?

You can call them loose objects/commit. This name is also used in the docs.

What does git do with these and is it possible to purge a specific orphan commit?

Git may eventually decide to clean these up (depending on gc.auto). This can also be done manually by running git gc --prune=now in the repository where you want to remove it (you need shell access). If you have a long reference chain referencing the object that is not referenced any more, you may want to add --aggressive: git gc --aggressive --prune=now.

If you don't have direct access, you could mirror the repository, run git gc --prune=now, delete the remote repository, recreate an empty repository and push everything from your local mirror.

Anyways, I would strongly recommend you to change/invalidate the leaked credentials as soon as possible as people could already have downloaded your commit (and the reviewer has seen those, too). When you are sure that your leaked credentials are not valid anywhere, you don't need to worry about unreferenced commits.

Form what you have described top of master is fixed and problem is only is someone checks out old version of code where stuff are broken.

There is no easy way to fix it. For that you need rewrite whole history and make sure that all copies of repository are updated with new history. This is organization nightmare you will always miss one repo which will be pushed back to main repository and you will come back to initial state. So do not try that.

The only reasonable solution is address scenario when someone checks out old version of code. If this is some branch, like: release-1.x.x then just cherry pick a commit which fixes this issue to that branch.

If developers have to checkout code to specific version/commit, they have to live with this problem as long this version of code needs some maintenance.

Important is to learn some lesson from this kind of problems:

• always create and check in .gitignore to repository when only you start new project.
• git hooks are a bit harder to configure, but are great solution to protect repo from unwanted corruptions
  • note there are tools github/gitlab/bitbucket/... which allows you to configure pull requests and configure git hooks to protect specific branches. Passing pull request code review is great way to protect you from unexpected (not covered by .gitignore and git hooks) bad changes
• when intern is joining a project make sure his git skills are at least a basic and he understands what should be tracked by repository and what should not be tracked.

If you want to squash the commits from B, then:

1. rebase B onto A first
2. squash B so now it is a single (or similar) commit on top of A
3. rebase A onto master

Simply use merge without fast-forward:

I did not see a squash feature directly through API.

You would need to:

• create a branch at HEAD-N commits, through the create ref API
• reset your current branch to HEAD-N sha, with force boolean parameter set to true?
• create a pull request from your new branch to your old reset branch
• merge the PR, with the merge_method parameter set to squash

Pretty convoluted, but it should work (entirely through script, without having to clone the repository).

If you intend to take each new commit from someone who offers you 50 commits (or any other number than 1), you must inspect each new commit. There is no Royal Road to this: it requires inspecting each commit.

If you intend to use git merge --squash or similar to convert all 50 of their commits into a single, new, different commit that just produces the same end result, then you can review the changes as a single change that produces the same end result, since that's what you will add to your repository.

That's really all there is to this. Pick what you are going to do, and review accordingly.

Every commit has two date-and-time stamps. One is called the author date and one is called the committer date.

When you make a new commit in the usual way, using git commit and no trickery, both are set to the same value. Git retrieves the current time from your computer clock, and if that's accurate, the new commit's two date-stamps are "now".

When you make a commit using git cherry-pick or something that internally uses the cherry-pick machinery (such as git rebase), Git normally preserves the original author of the commit, and the original author-date. You become the committer, and "now" is the committer date.

To see both time stamps with git log, use any of the formatting options that prints both. The simplest to use is git log --pretty=fuller.

The --since and --until (or --after and --before) options to git log use the committer date only. (I think there should be a way to specify author dates, but there isn't.)

How can I get same HEAD for master and dev after merge?

You can't. Well, technically you could, but you probably don't want to.

A branch in git points to a commit; that commit points to other commits, back through history. Each of those commits is identified by a unique hash; if two different commits had the same hash, everything would be horribly broken. That hash covers both the contents of the repository, and all the metadata of the commit, including what parents it has.

So if two different branches point at the same hash, those branches are identical - not just identical in their current content, but identical in their entire history.

The only way for that to happen is to always use "fast-forward" merges, everywhere, so that all your branches are actually just pointers in a single line of commits. In practice, that means rebasing things, a lot - for instance, every hotfix will probably require rebasing the whole of develop, and then rebasing all open feature branches onto that new develop.

That's a lot of work, and a lot of things that can go wrong, to avoid this:

I had to merge an empty commit with no diff.

Git was smart enough to recognise that no actual changes were needed, even though you'd merged two unrelated commits (remember: a squash merge throws away all history on the feature branch). That is it solving the problem for you.

The other solution, as pointed out in comments, is not to merge the feature to two places in the first place. Merge release to master, and then merge master to develop.