GIT - HowTo's about "repositories"

gitRepoRootDir="$HOME/myRepo"; fileToRemoveFromHistory_relativeToGitRepoRootDir='path/to/someFile'; tempDir='/path/to/temp/dir'
git clone "$gitRepoRootDir" "$tempDir" && cd "$tempDir" || { echo 'Press any key'; read; exit 1; }
echo 'SIZE BEFORE CLEANING'; du -sh .
git filter-branch --force --index-filter "git rm --cached --ignore-unmatch ${fileToRemoveFromHistory_relativeToGitRepoRootDir}" --prune-empty --tag-name-filter cat -- --all 1>/dev/null
echo 'SIZE AFTER FILTER-BRANCH'; du -sh .
git log -- "${fileToRemoveFromHistory_relativeToGitRepoRootDir}"
git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
git reflog expire --expire=now --all
git gc --prune=now
echo 'FINAL SIZE'; du -sh .

.git
dir1
dir2
dir3

1. clone the existing repository into a new place. This will become the new dir2 repository
2. remove everything from it which is not related to the contents of the dir2 directory

1. find the root of the repository
2. clone it :
   existingRepoRootDir='/root/of/existing/repository'; newRepoDir='/path/to/new/repository'; mkdir -p "$newRepoDir" && git clone "$existingRepoRootDir" "$newRepoDir"

   Cloning into '/path/to/new/repository'...
   done.

3. then enter the clone and keep only the dir2 stuff :
   cd "$newRepoDir" && git filter-branch --subdirectory-filter dir2 --prune-empty -- --all

   Rewrite dd39933a75594ac29d780de568e872fa22e1a480 (45/62) (1 seconds passed, remaining 0 predicted)
   Ref 'refs/heads/master' was rewritten
   Ref 'refs/remotes/origin/master' was rewritten
   WARNING: Ref 'refs/remotes/origin/master' is unchanged

4. The 2 previous steps as a big one-liner :
   existingRepoRootDir='/root/of/existing/repository'; relativePathToDirectoryToKeep='dir2'; newRepoDir='/path/to/new/repository'; mkdir -p "$newRepoDir" && git clone "$existingRepoRootDir" "$newRepoDir" && cd "$newRepoDir" && git filter-branch --subdirectory-filter "$relativePathToDirectoryToKeep" --prune-empty -- --all
5. Don't forget the final clean up :
   • in this new repository : reset the remotes
   • in the source repository : delete stuff you just extracted (or you'll have duplicate contents and it'll become a nightmare )

Using the vague word "get" on purpose because I still don't know whether its a matter of pull, fetch, or anything else .

Full demonstration :

Replay the full demo with the final git checkout + git pull :

git rev-parse --show-toplevel

On branch master
nothing to commit (use -u to show untracked files)

On branch master
Your branch is ahead of 'origin/master' by 2 commits.

1. git branch -vv

   * master 6f3d70e (a very interesting commit message)

   should be :

   * master 35ca599 [origin/master] (another highly interesting commit message)

2. git rev-parse --symbolic-full-name "@{u}"

   fatal: No upstream configured for branch 'master'

   should be :

   refs/remotes/origin/master

This is because the master local branch has no upstream origin/master remote branch to be compared to.

The presence or absence of an upstream setting mainly affects whether git status can tell you if you are ahead or behind, and whether git merge and git rebase can do their job with no additional parameters. So it's basically just a convenience setting.

1. Define a remote-tracking-branch for the current branch
2. Retry the commands above :
   1. git branch -vv

      * master 6f3d70e [origin/master: ahead 7] (a very interesting commit message)

   2. git rev-parse --symbolic-full-name "@{u}"

      refs/remotes/origin/master

3. And :
   git status

   On branch master
   Your branch is ahead of 'origin/master' by 7 commits.
   	

4. You may later wish to stop tracking the remote branch.

... without deleting it from the local filesystem :

git rm --cached file

... and delete it from the local filesystem :

git rm file, then commit file

To untrack an entire directory and delete it :

1. git rm -r path/to/directory/*
2. then make a simple commit : git commit -m 'cleaning'

git gc --aggressive --prune

Resulted in a ~10% volume decrease.

• git status --untracked-files=no
• shorter : git status -uno

This is dirty¹⁰⁰⁰ and is actually not recommended.

Before things are configured : can not push to non-bare repo

Get the initial configuration value

(nothing but UNIX FAILURE exit code)

Change the configuration value (source) :

Let's try to push again :

Counting objects: 6, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (6/6), done.
Writing objects: 100% (6/6), 697 bytes | 0 bytes/s, done.
Total 6 (delta 4), reused 0 (delta 0)
To gitServer:/path/to/repository
	f5c8ce7..629a87e	master -> master

Hack you have to do after each push to a non-bare repository :

Any information that has been committed to a public repository must be considered public, then compromised. So :

1. clean up your mess
2. forget about the disclosed passwords or keys, and generate new ones

1. Navigate to the repository's working directory :
   cd root/of/git/repository
2. Run git filter-branch while ...
   • forcing (--force) Git to process —but not check out (--index-filter)— the entire history of every branch and tag (--tag-name-filter cat -- --all)
   • and removing the specified file ('git rm --cached --ignore-unmatch path/to/fileContainingSensitiveData) and any empty commits generated as a result (--prune-empty)
   git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch path/to/fileContainingSensitiveData' --prune-empty --tag-name-filter cat -- --all
   Specify path/to/fileContainingSensitiveData, not just the file name.
   Example:

   git filter-branch --force --index-filter 'git rm --cached --ignore-unmatch ./test' --prune-empty --tag-name-filter cat -- --all

   Rewrite de1291f7f10da919f611358539e3d2e0acfd632f (1/9)rm 'test'
   Rewrite 023a969f60328055b6cab2e1a82e307760b7a308 (2/9)rm 'test'
   Rewrite aaffedfe16c297d02c2fee5eb72b740c91cae942 (3/9)rm 'test'
   Rewrite 8a766a9226e360ba0f147ae9c890cec200f958d7 (4/9)rm 'test'
   Rewrite 1f9bd643aa3495f46ca9470c021a56f8a0765c62 (5/9)rm 'test'
   Rewrite 2e22a397f2283f398038d9a44f451914c0a58f68 (6/9)rm 'test'
   Rewrite 15f247b46d558b057ccead7f7980c7f24b58879c (7/9)rm 'test'
   Rewrite e54ff82df52d8e7d02749b17e4fac4aa9386122e (8/9)rm 'test'
   Rewrite 5bbcaf42adac870f13295b2bbe2673807bf1e059 (9/9)rm 'test'
   
   Ref 'refs/heads/master' was rewritten
   Ref 'refs/remotes/origin/master' was rewritten

3. If fileContainingSensitiveData used to exist with a different path or name (git mv ), repeat the previous step for each previous path or name.
4. Add fileContainingSensitiveData to .gitignore to prevent committing again by mistake :
   echo fileContainingSensitiveData >> .gitignore; git add .gitignore; git commit -m "I won't commit fileContainingSensitiveData again."
5. Make sure your history is clean :
   git status
   git log --name-status

   http://stackoverflow.com/questions/1338728/delete-commits-from-a-branch-in-git
   git reset --hard commitId	WARNING, this deletes all commits from the current point back to commitId. Use with care !!!

6. Force-push your local changes to overwrite your public repository, as well as all the branches you've pushed up :
   git push origin --force --all
7. In order to remove the sensitive file from your tagged releases, you'll also need to force-push against your Git tags :
   git push origin --force --tags
8. Ask others to rebase instead of merging to avoid sending back the compromised data
9. After a while, once sure we've not broken anything (and with Git ≥ 1.8.5) :

   git for-each-ref --format='delete %(refname)' refs/original | git update-ref --stdin
   git reflog expire --expire=now --all
   git gc --prune=now

• smallRepo : a repository I'd like to "melt" into another bigger repository : bigRepo
• bigRepo : a repository that will "swallow" smallRepo and its history

Before starting this procedure, make sure there are no uncommitted changes on both repositories. commit or stash them accordingly.

1. cd path/to/bigRepo
2. git remote add small path/to/smallRepo
3. git fetch small
4. git checkout -b small small/master
   At this step, all files are imported into the root of "bigRepo". See the "git ls-files | xargs mv + commit" hack below
5. git checkout master
6. git merge small --allow-unrelated-histories
7. git remote rm small
8. git branch -d small

• less .git/config
• git config

1. Fork source project from GitHub UI
2. Get the URL of your forked version of the project : https://github.com/myGitHubLogin/projectName.git
3. Get a local copy of your forked repository : git clone https://github.com/myGitHubLogin/projectName.git
4. Enter your local work directory : cd projectName
5. Register the remote repo (named upstream by GitHub) : git remote add upstream https://github.com/projectOwner/projectName.git
6. git fetch upstream
7. Code, and commit to the local repository. Then push to your GitHub repository : git push origin master
8. On GitHub UI, open your fork's webpage, then Pull-request
9. Add title and details to the pull request, then submit.
10. Done !

Stuff below could be obsolete / wrong

git clone https://github.com/sni/Thruk.git
git remote add --track master upstream git://github.com/Httqm/Thruk.git
git branch newFeature
git checkout newFeature
[do some code modifications, commit]
git push upstream newFeature (?)

checkout is the SVN command to get a local copy of a project from its main repository (when joining a team, for instance).
Git also has a checkout command, but it has a different meaning.
The Git equivalent of SVN checkout is git clone.

clone from a remote host over SSH (I can log in there with ssh stuart@server) :

git clone stuart@server:/path/to/repository /local/path

• on server, there is /path/to/repository/.git/
• locally, I'll get /local/path/.git/

clone over SSH and "git checkout" the myDevelopmentBranch branch :

git clone git@host:/path/to/myGreatProject.git -b myDevelopmentBranch /path/to/local/directory

If /path/to/local/directory is not specified, the files will be extracted as ./myGreatProject/*