1. Cloning a git branch

git clone -b solution https://github.com/SNCodingChallenge/stm_challenge_krishna_paudel.git

2. Change push repository

   First clone the git project into your local:
   git clone [email protected]:/opt/git/MyProject.git
 
 Go into MyProject folder and hen remove the .git folder which clears out all the old information. Run the command:

git init 

Which regenerates git information. Now we add remote repository to push:

  git remote add [email protected]:/repos/git/MyNewProject.git 

Now verify:

  git remote -v 

3. Create a new repository in the server

 Create a folder MyNewProject.git into Server repository.
 Go into the directory and execute

   git init –bare

Give access rights to the git user. (Normally we set the owner of the directory as git)

4. Push to the remote repository

git push origin master

5. Commit changes to the local repository

git commit -m “Message”.

6. Merge updates from a branch

git pull [origin branch]

Example:
a) Merging from the same branch
git pull

b) Merging from master branch
git pull origin master

Note: If sometimes, the pull merging gives the following failure:
“refusing to merge unrelated histories”
Then the following command will be useful.

git pull origin master –allow-unrelated-histories

7. Disable http ssl verification

We need this when we create a certificate by ourselves for our private purposes. In that situation, we have to disable SSL verification or simply use ssh. 

git config –global http.sslverify “false”

 
8. Store GIT credentials
 
Sometimes we need this feature if you are tired of providing the username and password while executing the git command. The solution for this is to store credentials,
 
git config –global credential.helper store

It stores the credential and you never need to provide the username and password.

 
There are some options too:
git config –global credential.helper ‘cache –timeout=600’
git config –global credential.helper cache

10. Display the branch name in the terminal

 
If we display the branch name in the terminal, it helps us to know which branch we are working on and also prevents mistakenly working on other unintended branches.
 
I found the script to run to activate this feature in the terminal. 
 
# Show git branch name
force_color_prompt=yes
color_prompt=yes
parse_git_branch() {
 git branch 2> /dev/null | sed -e ‘/^[^*]/d’ -e ‘s/* (.*)/(1)/’
}
if [ “$color_prompt” = yes ]; then
 PS1=’${debian_chroot:+($debian_chroot)}[33[01;32m]u@h[33[00m]:[33[01;34m]w[33[01;31m]$(parse_git_branch)[33[00m]$ ‘
else
 PS1=’${debian_chroot:+($debian_chroot)}u@h:w$(parse_git_branch)$ ‘
fi
unset color_prompt force_color_prompt
 
 
Just save this file in “git-branch-name.sh” in your preferred location and run this at the time the system starts.
To run this script while the system loads, we need to append the following lines in the .bashrc file. 
# To display git branch name in the terminal
if [ -f /Backup/scripts/git-branch-name.sh ]; then
   . /Backup/scripts/git-branch-name.sh 
fi 
 
11. How to squash comments in git 
 
When we have implemented a single feature, that consists of multiple commits, we can squash the commits and provide a sensible commit message before merging into the branch. This way of squashing will provide you clear history in the branch. 
 
First, we get the last n commits, where we can squash or pick the comments. 
git rebase -i HEAD~2

Then we just pick the commits (with pick or p) or squash the commits (squash or s) and save. Then we have another window where you can simply comment out the unnecessary commit. After everything is done, we can push the changes by using force commit

git push -f origin [branch]

If we want to cancel the rebase process, we can simply use the following command

git rebase --abort

12. Merge or Rebase?

We can combine the changes from the two branches. The first and most popular method is using

git pull origin [branch] == git fetch & git merge origin [branch]

This way of merging will get the changes from the branch, combine them with your changes, and create a new commit.

The alternative to this is rebasing.

git rebase origin [branch] == git pull --rebase origin [branch]

This will get the latest changes from the branch and put your commits in the current branch on top of it.

After this, resolve the conflicts, and then after the rebase process is complete, you can continue with rebasing

git rebase --continue

If there is some problem while rebasing, we can simply abort the rebase process

git rebase --abort

Related Posts

Leave a Reply

Your email address will not be published. Required fields are marked *