• General Shell Commands
• SSH Commands
• tmux commands
• Vim Commands
• Git Commands
• i3wm commands
• Brew bundle

General shell commands

SSH Commands

SSH Tunnelling

To access servers hosted on the remote machine from the local machine

$ ssh -NL port1_server:localhost:port1_local [-NL port2_server:localhost:port2_local]{multiple ports possible} username@remote-ip-address

Example:

$ ssh -NL 8888:localhost:8888 [email protected]

Copy multiple files from remote to local:

$ scp username@remote-ip:/some/remote/directory/\{file1,file2,file3\} /localpath
$ scp username@remote-ip:'/path1/file1 /path2/file2 /path3/file3' /localPath

Other ssh commands

Generate ssh key:

Using ed25519 (more secure: Recommended)

$ ssh-keygen -t ed25519

Using RSA

$ ssh-keygen -t rsa -b 3072

Save ssh host info Modify this file: ~/.ssh/config

Host *
    AddKeysToAgent yes
    UseKeychain yes
    IdentityFile ~/.ssh/id_rsa (path/to/key)

Host targaryen
    HostName 192.168.1.10
    User daenerys
    Port 7654

Host tyrell
    HostName 192.168.10.20

Host martell
    HostName 192.168.10.50

Host *ell
    User oberyn

Host * !martell
    LogLevel INFO

Host *
    User root
    Compression yes

Save ssh password so that no need to re-enter every time

Run this in client (not server)

ssh-copy-id -i path/to/key.pub username@server-ip-address

Example:

ssh-copy-id -i ~/.ssh/id_rsa.pub [email protected]

Open server in nautilus / file explorer in linux

File explorer: Other locations > Connect to server > sftp://username@ip/

tmux commands

Vim commands

I. Pure Vim

Syntax:

Verbs (operations) + Noun (text on which operation is performed)

[count] [operation] [text object / motion]

Run bash commands in vim

:[.]!command

. (dot) - outputs the command into the current buffer

1. VIM Verbs (operations)

2. VIM Nouns (text)

i. Text Objects

Must be combined with verbs

Combination examples:

ii. Motions

Can be combined with verbs or used independently

Combination examples:

3. Other important vim commands

4. Useful key remappings

5. Using Args

Args are list of files initially opened. So, it’s a subset of buffers.

6. Scrolling and motions

II. Vim Plugins commands

Install any vim plugin manager like vim-plug.

To apply latest settings:

:source $MYVIMRC

Ranger

First, instll ranger

Mac

brew install ranger

Linux

sudo apt install ranger

Install ranger plugin for vim

" Ranger in vim
Plug 'francoiscabrol/ranger.vim'
" Dependency for ranger in neovim
Plug 'rbgrouleff/bclose.vim'

When ranger is open in vim or externally

1. vim-surround commands

Install Plug tpope/vim-surround

Examples:

2. Git plugins commands

Install these plugins first

" Show differences with style
Plug 'mhinz/vim-signify'
" Main GIT PLugin :Git
Plug 'tpope/vim-fugitive'
" Git Hub plugin, enables :Gbrowse
Plug 'tpope/vim-rhubarb'
" Git commit browser
Plug 'junegunn/gv.vim'
" Git commit history in each line

3. Coc commands

Install COC plugin first

" Intellisense
Plug 'neoclide/coc.nvim', {'branch': 'release'}

4. coc-python

Install coc-python first

:CocInstall coc-python

5. FZF

Install fzf in system and fzf plugin

OSx

brew install fzf

# To install useful key bindings and fuzzy completion:
$(brew --prefix)/opt/fzf/install

brew install ripgrep

Linux

sudo apt install fzf
sudo apt install ripgrep

FZF Plugin

Plug 'junegunn/fzf', { 'do': { -> fzf#install() } }
Plug 'junegunn/fzf.vim'
Plug 'airblade/vim-rooter'

6. Startify

Install Startify Plugin for Project management

" Start Screen
Plug 'mhinz/vim-startify'

7. vim-commentary

" Better Comments
Plug 'tpope/vim-commentary'

Easy remapping |nnoremap <leader>/| :Commentary<CR> |vnoremap <leader>/| :Commentary<CR>

Git commands

Ignore files that have already been committed to the repo

$ git rm -r --cached .
$ git add .
$ git commit -m "Clean up ignored files"

Hard delete unpublished commits

git reset --hard commit_id (reset to the particular commit. It will destroy any local modifications.)

Alternatively, if there’s work to keep

git stash
git reset --hard commit_id
git stash pop

This saves the modifications, then reapplies that patch after resetting. You could get merge conflicts, if you’ve modified things which were changed since the commit you reset to.

Undo published commits with new commits

This will create three separate revert commits:

git revert a867b4af 25eee4ca 0766c053

It also takes ranges. This will revert the last two commits:

git revert HEAD~2..HEAD

Similarly, you can revert a range of commits using commit hashes:

git revert a867b4af..0766c053

Reverting a merge commit

git revert -m 1 <merge_commit_sha>

To get just one, you could use rebase -i to squash them afterwards Or, you could do it manually (be sure to do this at top level of the repo) get your index and work tree into the desired state, without changing HEAD:

git checkout 0d1d7fc32 .

Then commit. Be sure and write a good message describing what you just did

git commit

Git reset

git reset does know five “modes”: soft, mixed, hard, merge and keep. I will start with the first three, since these are the modes you’ll usually encounter. After that you’ll find a nice little a bonus, so stay tuned.

• soft

  When using

    git reset --soft HEAD~1
  

  you will remove the last commit from the current branch, but the file changes will stay in your working tree. Also the changes will stay on your index, so following with a git commit will create a commit with the exact same changes as the commit you “removed” before.

• mixed

  This is the default mode and quite similar to soft. When “removing” a commit with

    git reset HEAD~1
  

  you will still keep the changes in your working tree but not on the index; so if you want to “redo” the commit, you will have to add the changes (git add) before commiting.

• hard

  When using

    git reset --hard HEAD~1
  

  you will lose all uncommited changes in addition to the changes introduced in the last commit. The changes won’t stay in your working tree so doing a git status command will tell you that you don’t have any changes in your repository.

  Tread carefully with this one. If you accidentally remove uncommited changes which were never tracked by git (speak: committed or at least added to the index), you have no way of getting them back using git.

• Bonus (keep)

    git reset --keep HEAD~1
  

  is an interesting and useful one. It only resets the files which are different between the current HEAD and the given commit. It aborts the reset if anyone of these files has uncommited changes. It’s basically acts as a safer version of hard.

  This mode is particularly useful when you have a bunch of changes and want to switch to a different branch without losing these changes - for example when you started to work on the wrong branch.

Remove sensitive file from github repo history

git filter-branch --index-filter "git rm -rf --cached --ignore-unmatch path_to_file" HEAD
git push -f origin master

Other git commands

git rm | rm plus git add combined
git rm --cached | file removed from the index (staging it for deletion on the next commit), but keep your  copy in the local file system.

i3wm commands

• pavucontrol
• alsamixer

Alt+Shift- Change keyboard language

Brew bundle for OSx

Usage

Create a Brewfile in the root of your project with:

touch Brewfile

Add your dependencies in your Brewfile:

tap "homebrew/cask"
tap "user/tap-repo", "https://[email protected]/user/homebrew-tap-repo.git"
cask_args appdir: "/Applications"

brew "imagemagick"
brew "denji/nginx/nginx-full", args: ["with-rmtp-module"]
brew "[email protected]", restart_service: true, link: true, conflicts_with: ["mysql"]

cask "firefox", args: { appdir: "~/my-apps/Applications" }
cask "google-chrome"
cask "java" unless system "/usr/libexec/java_home --failfast"

mas "1Password", id: 443987910

whalebrew "whalebrew/wget"

cask and mas entries are automatically skipped on Linux. Other entries can be run only on (or not on) Linux with if OS.mac? or if OS.linux?.

Install

You can then easily install all dependencies with:

brew bundle

Any previously-installed dependencies which have upgrades available will be upgraded.

brew bundle will look for a Brewfile in the current directory. Use --file to specify a path to a different Brewfile, or set the HOMEBREW_BUNDLE_FILE environment variable; --file takes precedence if both are provided.

My .Brewfile is stored in the home directory and the HOMEBREW_BUNDLE_FILE environment variable is set to ~/.Brewfile

You can skip the installation of dependencies by adding space-separated values to one or more of the following environment variables:

• HOMEBREW_BUNDLE_BREW_SKIP
• HOMEBREW_BUNDLE_CASK_SKIP
• HOMEBREW_BUNDLE_MAS_SKIP
• HOMEBREW_BUNDLE_WHALEBREW_SKIP
• HOMEBREW_BUNDLE_TAP_SKIP

brew bundle will output a Brewfile.lock.json in the same directory as the Brewfile if all dependencies are installed successfully. This contains dependency and system status information which can be useful in debugging brew bundle failures and replicating a “last known good build” state.

You can opt-out of this behaviour by setting the HOMEBREW_BUNDLE_NO_LOCK environment variable or passing the --no-lock option.

You may wish to check this file into the same version control system as your Brewfile (or ensure your version control system ignores it if you’d prefer to rely on debugging information from a local machine).

Dump

You can create a Brewfile from all the existing Homebrew packages you have installed with:

brew bundle dump

The --force option will allow an existing Brewfile to be overwritten as well. The --describe option will output a description comment above each line. The --no-restart option will prevent restart_service from being added to brew lines with running services.

Cleanup

You can also use a Brewfile to list the only packages that should be installed, removing any package not present or dependent. This workflow is useful for maintainers or testers who regularly install lots of formulae. To uninstall all Homebrew formulae not listed in the Brewfile:

brew bundle cleanup

Unless the --force option is passed, formulae that would be uninstalled will be listed rather than actually be uninstalled.

Check

You can check there’s anything to install/upgrade in the Brewfile by running:

brew bundle check

This provides a successful exit code if everything is up-to-date, making it useful for scripting.

For a list of dependencies that are missing, pass --verbose. This will also check all dependencies by not exiting on the first missing dependency category.

List

Outputs a list of all of the entries in the Brewfile.

brew bundle list

Pass one of --casks, --taps, --mas, --whalebrew or --brews to limit output to that type. Defaults to --brews. Pass --all to see everything.

Note that the type of the package is not included in this output.

Exec

Runs an external command within Homebrew’s superenv build environment.

brew bundle exec -- bundle install

This sanitized build environment ignores unrequested dependencies, which makes sure that things you didn’t specify in your Brewfile won’t get picked up by commands like bundle install, npm install, etc. It will also add compiler flags which will help find keg-only dependencies like openssl, icu4c, etc.

Restarting services

You can choose whether brew bundle restarts a service every time it’s run, or only when the formula is installed or upgraded in your Brewfile:

# Always restart myservice
brew 'myservice', restart_service: true

# Only restart when installing or upgrading myservice
brew 'myservice', restart_service: :changed

References

• Vim: Tutorial on Editing, Navigation, and File Management (2018)
• Mastering the Vim Language
• Stack Overflow: Git commits