Azman @UniMAP

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
====== Git Stuff ======

From [[https://git-scm.com|here]],

//"Git is an open source, distributed version control system  designed to handle everything from small to very large projects with speed and efficiency."//

Some useful configurations before starting with git. I have this [[https://codeberg.org/azman/my1shell/src/branch/master/gitstart|simple script]] that I run on a new machine I want to work on.

===== Create, Clone, Add, Commit =====

Create new repo <code>$ mkdir /path/to/project ; cd /path/to/project ; git init</code>
Clone a repo <code>$ git clone git://server/path/to/project.git</code>
Add everything in current path to repo <code>$ git add .</code>
Add file(s) to repo @ next commit <code>$ git add <file1> <file2></code>
Commit changes added <code>$ git commit</code>
Commit ALL changes in currently tracked files <code>$ git commit -a</code>

===== Create/Apply Patches =====

Create a diff patch <code>$ git diff COMMIT_1 COMMIT_2 > PATCHFILE</code>
Apply a diff patch <code>$ git apply < PATCHFILE</code>
Create a formatted patch (can also use -n where n is the number of previous commits to create patches for) <code>$ git format-patch -o /path/to/patches/ -1</code>
Apply a formatted patch <code>$ git am < PATCHFILE</code>
Apply a formatted patch (create new date) <code>$ git am --ignore-date < PATCHFILE</code>

Create formatted patches (note: sha1id1..sha1id2 is the range of commits used to create patches) <code>$ git format-patch -o /path/to/patches/ sha1id1..sha1id2</code>
To rename created patch(es) with commit timestamp <code> for a in *.patch ; do l=$(cat $a|grep 'Date: ') ; d=$(date +"%Y%m%d%H%M%S" -d "${l#*: }") ; mv $a "$d${a:4}" ; done</code>
To apply the patches (stopping on error) <code>for a in ~/temp/patches/*.patch ; do git am <$a ; [ $? -ne 0 ] && break; done</code>

===== Branching/Merging =====

Create new local branch <code>$ git branch <local-branch></code>
Remove local branch (-D to force) <code>$ git branch -d <local-branch></code>
Create a local branch to track remote branch <code>$ git checkout --track -b <local-branch> <remote-branch></code>
Set current local branch to track a remote branch <code>$ git branch -u <remote>/<branch></code>

===== Basic Management =====

Checkout specific commit <code>$ git checkout COMMIT</code>
Force reset to a specific commit <code>$ git reset --hard [COMMIT]</code>
Clean up untracked file(s)/folder(s) <code>$ git clean -f -d</code>

Re-committing to add forgotten items
<code>
$ git reset --soft HEAD^
# <do the forgotten thingy, if necessary do a git add>
$ git commit
</code>

Changing First Commit Message
<code>
# checkout the root commit
git checkout <sha1-of-root>
# amend the commit
git commit --amend
# rebase all the other commits in master onto the amended root
git rebase --onto HEAD HEAD master
</code>

Manage Tag(s)
<code>
# git tag
# git tag <newtag>
# git tag -d <oldtag>

# git fetch --tags
# git push --tags

# (this works on github - unknown elsewhere)
# git push <remote> :<oldtag>
</code>

Other commands:
<code>
# git config --list
# git config remote.origin.url NEW_URL
# git pull ANOTHER_URL master

# git branch -vv
# git branch -u <remote>/<remote_branch> <local_branch>

# git bundle create <somefile> HEAD
# git pull <somefile> HEAD

# git archive --format=tar --prefix=<folder-prefix>/ <tag/commit> | gzip >/path/to/tarball-release.tar.gz
</code>

Merge to master branch while on other branch (without checkout):
<code># git fetch . <src_branch>:master</code>
Check log for master branch while on other branch (without checkout):
<code># git log master</code>

Merge specific file(s) from another branch
<code># git checkout <src_branch> file1 [file2 file3...]</code>

Create a GIT repository on shared hosting (with SSH access) and publish through HTTP
<code>
# sshfs -p <ssh-port> -o workaround=rename user@server:public_html /local/mount/path
# cd /local/mount/path
# mkdir repo
# cd repo
# git clone --bare /local/repo <repo-name>
# cd <repo-name>
# git --bare update-server-info
# cp hooks/post-update.sample hooks/post-update
</code>

Running GIT Daemon:
<code>
git daemon --reuseaddr --base-path=/path/to/repos --export-all --verbose --enable=receive-pack
</code>

===== Advanced Git =====

Merging two different repositories with histories intact (the new one on top of the old)

  * assuming repoA and repoB (repoB the same project with different code-base)
  * we want to have repoB override repoA, but want to keep repoA history within that project
  * so, first create a remote on repoA pointing to repoB
    * <code>git remote add <repoB_name> <repoB_url></code>
  * fetch repoB history?
    * <code>git fetch --all</code>
  * here is where we overwrite repoA (but keep the history...)
    * <code>git merge repoB_name/master --strategy-option theirs --allow-unrelated-histories</code>

Rescuing from ''git reset --hard''

//**Note:** This DOES NOT work all the time, I guess... because ''git reset --hard'' should remove every record. But, this may... (and in my case, once, did) work.//

<code>git reset HEAD@{1}</code>

Remove remote branch
<code>git push origin --delete {branch}</code>

If the remote branch has been removed, use this to remove local reference
<code>git remote update origin --prune</code>

Prepare diff with binary content
<code>git diff-index master --binary >bin.patch</code>

List tracked files (recursively)
<code>git ls-tree --name-only -r <branch></code>

List untracked files
<code>git ls-tree --others</code>

List ignored files
<code>git ls-files --ignored --exclude-standard</code>

===== Local Management =====

Fetch updates from downstream (assume in branch staging)
<code shell>
$ for that in $(find . -not \( -path "./.git/*" -prune \) -type f) ; do git checkout staging ${that:2} ; done
</code>

//Dumping ground... will sort this out later...//

<code shell>
# list github remote
here=$(pwd) ; for a in $(find $here -mindepth 1 -maxdepth 1 -type d) ; do base=$(basename $a) ; pick= ; for b in $(cat ~/temp/github.txt) ; do [ "$base" = "$(basename $b)" ] && pick=$b && break ; done ; [ ! -z "$pick" ] && continue ; pick=$a ; cd $pick ; what=$(git remote -v | grep -e "^github" | grep fetch) ; [ -z "$what" ] && continue ; echo "-- REMOVE! ($pick)($what)" ; done ; cd $here

# list & remove github remote
here=$(pwd) ; for a in $(find $here -mindepth 1 -maxdepth 1 -type d) ; do base=$(basename $a) ; pick= ; for b in $(cat ~/temp/github.txt) ; do [ "$base" = "$(basename $b)" ] && pick=$b && break ; done ; [ ! -z "$pick" ] && continue ; pick=$a ; cd $pick ; what=$(git remote -v | grep -e "^github" | grep fetch) ; [ -z "$what" ] && continue ; echo "-- REMOVE! ($pick)($what)" ; git remote rm github ; done ; cd $here

# list github branch
here=$(pwd) ; for a in $(find $here -mindepth 1 -maxdepth 1 -type d) ; do base=$(basename $a) ; pick= ; for b in $(cat ~/temp/github.txt) ; do [ "$base" = "$(basename $b)" ] && pick=$b && break ; done ; [ ! -z "$pick" ] && continue ; pick=$a ; cd $pick ; what=$(git branch | grep github) ; [ -z "$what" ] && continue ; that=$(git remote -v | grep -e "^github" | grep fetch) ; [ ! -z "$that" ] && continue ;  echo "-- Branch: $pick ($what)" ; done ; cd $here

# list & remove github branch
here=$(pwd) ; for a in $(find $here -mindepth 1 -maxdepth 1 -type d) ; do base=$(basename $a) ; pick= ; for b in $(cat ~/temp/github.txt) ; do [ "$base" = "$(basename $b)" ] && pick=$b && break ; done ; [ ! -z "$pick" ] && continue ; pick=$a ; cd $pick ; what=$(git branch | grep github) ; [ -z "$what" ] && continue ; that=$(git remote -v | grep -e "^github" | grep fetch) ; [ ! -z "$that" ] && continue ;  echo "-- Branch: $pick ($what)" ; git branch -D github  ; done ; cd $here
</code>