Git Workflow Commands

This is less of an article and more of a list of useful Git commands I use day-to-day, for personal reference and hopefully to help out others. Most of these are based on working with GitHub.

**To get a repo**
```
git clone https://github.com/account/repo.git
git config user.name myusername
git config user.username myusername
git config user.email myusername@noreply.users.github.com
```
Change 'myusername' to your own username
 

**To update from upstream (sync a fork)**
```
git checkout master
git remote add upstream git://github.com/user/repo.git
git pull upstream master
```
 

**To create a branch**
```
git checkout basebranch
git pull origin basebranch
git checkout -b newbranch
```
 

**To commit**
```
git add .
git checkout -m "message"
```
or if you only want to commit files you have modified, skip the add stage:
```
git checkout -am "message"
```
 

**To commit part of a file**
```
git add -p filename
```
-p is short for --patch 
This command brings up an interactive patch menu containing 'hunks', which is what Git thinks are suitable chunks of code 
Answer hunks as: 
[y]es - add hunk 
[n]o - don't add hunk 
[s]plit - split hunk into smaller hunks 
[e]dit - modify hunk (change +/-/# lines) 
[q]uit - quit, aborting all changes 
 

**To undo adding files to staging area**
```
git reset HEAD filename
```
 

**To change a commit message**
```
git commit --amend -m "newmessage"
```
 

**To view changes**
```
git diff
git dif --staged
```
Adding --staged (or --cached) views staged changes
 

**To undo and go back 1 commit**
```
git reset --soft HEAD~1
git reset --hard HEAD~
```
--soft keeps local changes 
--hard destroys local changes (careful with this one!)
 

**To view all logs in branch compactly**
```
git --no-pager log --oneline
```
 

**To merge**
```
git rebase -i commitSHA
git commit --amend
git push origin mergingbranch --force
git checkout basebranch
git pull origin basebranch
git checkout mergingbranch
git rebase master 
git push origin mergingbranch --force 
git checkout master
git merge --no-ff mergingbranch
git pull origin master
```
The first command, ```git rebase -i commitSHA```, uses the commit hash as the commit to rebase from 
An alternative to this command is ```git rebase -i HEAD~10``` where 10 is the number of commits to rebase 
```git commit --amend``` changes the commit message (Git by default merges all commit messages from the rebase to make a new one) 
Make sure to resolve conflicts and ensure all test builds pass during ```git rebase master```! 
Using ```git merge --no-ff``` commits without a fast-forward, to maintain a proper commit chronology without any real downsides 
 

**To tag for release**
```
git tag -am "release details" 1.3.2
git push origin branchname --tags
```
Change 1.3.2 to release number, add release details
 
 
**To change a tag's details**
```
git tag tagname tagname -a -f
git push origin branchname --tags --force
```
 

**To view nearest tags to current commit**
```
git describe --tags --abbrev=0
```
 

**To update 'develop' branch with new release**
```
git checkout release-1.0
git pull origin release-1.0
git checkout develop
git pull origin develop
git merge --no-ff release.1.0
git push origin develop
```

Vim Statusline Generator


## The easy way to create your Vim statusline

While I should have been writing my dissertation, procrastination has led me to this: my weekend project is complete. The vanilla Vim statusline generator is here. It was developed using pure JavaScript, with layout help from Bootstrap 4.

View the generator here: [Vim Statusline Generator](http://tdaly.co.uk/projects/vim-statusline-generator).

In it's current state it has the ability to add different options as described in my statusline post [here](http://tdaly.co.uk/posts/vanilla-vim-statusline), such as the modification flag, short/long filename, line number, and more. I've also added some vimscript functions such as getting the current Git branch of the focussed buffer, the mode (normal/insert/visual), and the current time. I also thought it made sense to include some separators to allow for a bit more personalisation, and different colour choices.

If anyone has any comments or improvements, such as new flags to add that I missed, I'd appreciate feedback - email me at _tom (at) tdaly.co.uk_.


Vanilla Vim Statusline

## Why Powerline plugins are often unnecessary 

For many, the use of plugins such as [powerline](https://github.com/powerline/powerline) and [airline](https://github.com/vim-airline/vim-airline) within Vim are de facto standard. They produce fancy statuslines that indicate a few main things; the mode you're currently in (insert, normal, visual), any version control information (such as the current Git branch), the filename, file type, file encoding and current directory. Don't get me wrong, some of these statusline plugins do look good. They're customisable with themes and colours, link to other plugins well and introduce special fonts that'll make your fellow Vimmers ask "What's that at the bottom of your screen, and how do I get it?".

My issue with these plugins is that a lot of the time, they are bloated. They include special extra features that not everyone turns on, and even the supposedly streamlined versions such as vim-airline that claims to be 'lighter than air' as it uses solely Vimscript - as opposed to powerline's Python code - are a bit bulky. Even to install these plugins, a plugin manager is necessary if you don't want to compile and configure the code from source.

As an extremely lightweight alternative to these plugins, Vim's own statusline can be modified to achieve (most) of the same things. Everything listed above can be achieved with a few simple lines added to the bottom of your pre-existing .vimrc. My current statusline looks like this:

![](../static/vim_statusline.png)

This statusline boasts of customisable colours, mode displays, the current working directory, the current buffer's file path, the current line number and total lines, file type and Git information. To get all of this information into a single statusline, my current .vimrc contains:

``` css
"" statusline
set laststatus=2
set statusline= " left align
set statusline+=%2*\ " blank char
set statusline+=%2*\%{StatuslineMode()}
set statusline+=%2*\
set statusline+=%1*\ <<
set statusline+=%1*\ %f " short filename 
set statusline+=%1*\ >>
set statusline+=%= " right align
set statusline+=%*
set statusline+=%3*\%h%m%r " file flags (help, read-only, modified)
set statusline+=%4*\%{b:gitbranch} " include git branch
set statusline+=%3*\%.25F " long filename (trimmed to 25 chars)
set statusline+=%3*\::
set statusline+=%3*\%l/%L\\| " line count
set statusline+=%3*\%y " file type
hi User1 ctermbg=black ctermfg=grey guibg=black guifg=grey
hi User2 ctermbg=green ctermfg=black guibg=green guifg=black
hi User3 ctermbg=black ctermfg=lightgreen guibg=black guifg=lightgreen

"" statusline functions
function! StatuslineMode()
 let l:mode=mode()
 if l:mode==#"n"
 return "NORMAL"
 elseif l:mode==?"v"
 return "VISUAL"
 elseif l:mode==#"i"
 return "INSERT"
 elseif l:mode==#"R"
 return "REPLACE"
 endif
endfunction

function! StatuslineGitBranch()
 let b:gitbranch=""
 if &modifiable
 try
 lcd %:p:h
 catch
 return
 endtry
 let l:gitrevparse=system("git rev-parse --abbrev-ref HEAD")
 lcd -
 if l:gitrevparse!~"fatal: not a git repository"
 let b:gitbranch="(".substitute(l:gitrevparse, '\n', '', 'g').") "
 endif
 endif
endfunction

augroup GetGitBranch
 autocmd!
 autocmd VimEnter,WinEnter,BufEnter * call StatuslineGitBranch()
augroup END
```

This doesn't look like much code and you're right, it's not. That's the beauty of using Vim's existing statusline functions. Most of what you want from a statusline can be displayed without downloading a plugin (or even a plugin manager to boot). The two custom functions at the end to convert the mode into a string and get the status of the current Git branch are extras, and can be modified to your liking if you want to change the VCS that Vim reads from. The colours of the statusline can also be modified to your liking by simply changing the 'User1', 'User2' and 'User3' colours to another set of values.

**If you want an easy way to customise your Vim statusline without any configuration, check out this post:** [Vim Statusline Generator](http://tdaly.co.uk/post/vim-statusline-generator)

Welcome to my space of the internet