I’ve also ported both the prompt and the tab expansion to work with Mercurial.

Much like the git prompt, the Mercurial prompt shows the name of the branch as well as other information. The prompt shows the following information:

• “hg” – Identifies this as a mercurial repository (so I can tell whether I’m using git or mercurial)
• “default” – We’re currently on the “default” branch
• “+<number>” – Number of files that have been added but not yet committed
• “~<number>” – Number of files that have been modified but not yet committed
• “-<number>” – Number of files that have been removed but not yet committed
• “?<number>” – Number of untracked files in the repository
• “!<number>” – Number of missing files

I’ve also written some basic tab expansion functionality that provides completion for hg commands as well as hgtk commands (the TortoiseHg command line tool).

Code can be found in the posh-hg repository (somewhat ironically hosted on GitHub).

Custom Prompt

The first thing that I have is a custom prompt when I’m within a Git repository:

This prompt shows various pieces of information about the current git repository:

• “1.3” – The name of the current branch that I’m working on
• “+0” – The number of files that have been added since the last commit
• “~1” – The number of files that have been modified since the last commit
• “-0” – The number of files that have been deleted since the last commit
• “!” – Whether or not there are untracked files in the working directory

Essentially this is implemented by writing a custom “prompt” function inside your Powershell profile. My colleague Mark Embling wrote about this in detail.

Tab Expansion

I also use a custom TabExpansion function that provides tab-completion for common git commands.

For example, if I type “git ch<tab>” then powershell will insert “git checkout”. This is taken further by providing auto-completion for branch names and remote names, so typing “git push <tab>” would automatically fill in “git push origin” and “git push origin <tab>” would then cycle through my local branches.

To implement a custom TabExpansion function, you’ll need to open your Powershell profile (stored in Documents\WindowsPowershell\Profile.ps1). If this file doesn’t exist, then you’ll need to create it.

Next, create a function called “TabExpansion”. This function takes two arguments – the last word that was entered before the user hit the tab key as well as the entire line that has been entered into the prompt. Inside this function, we want to parse the entire line in order to extract the last “block” (ie the last piece of input not separated by a semicolon or a pipe):

function TabExpansion($line, $lastWord) {
  $LineBlocks = [regex]::Split($line, '[|;]')
  $lastBlock = $LineBlocks[-1] 
}

Next, we can use a regular expression to see whether the block begins with “git “. If so, then we’ll hand the input off to a function called “gitTabExpansion”:

function TabExpansion($line, $lastWord) {
  $LineBlocks = [regex]::Split($line, '[|;]')
  $lastBlock = $LineBlocks[-1] 
 
  switch -regex ($lastBlock) {
    'git (.*)' { gitTabExpansion($lastBlock) }
  }
}

The gitTabExpansion again uses regular expressions to identify what the user has entered and acts appropriately:

function gitTabExpansion($lastBlock) {
     switch -regex ($lastBlock) {
 
        #Handles git branch -x -y -z <branch name>
        'git branch -(d|D) (\S*)$' {
          gitLocalBranches($matches[2])
        }
 
        #handles git checkout <branch name>
        #handles git merge <brancj name>
        'git (checkout|merge) (\S*)$' {
          gitLocalBranches($matches[2])
        }
 
        #handles git <cmd>
        #handles git help <cmd>
        'git (help )?(\S*)$' {      
          gitCommands($matches[2])
        }
 
        #handles git push remote <branch>
        #handles git pull remote <branch>
        'git (push|pull) (\S+) (\S*)$' {
          gitLocalBranches($matches[3])
        }
 
        #handles git pull <remote>
        #handles git push <remote>
        'git (push|pull) (\S*)$' {
          gitRemotes($matches[2])
        }
    }	
}

Hopefully the comments are pretty self explanatory. The gitLocalBranches, gitCommands and gitRemotes functions invoke the appropriate git command and parse the output:

function gitCommands($filter) {
  $cmdList = @()
  $output = git help
  foreach($line in $output) {
    if($line -match '^   (\S+) (.*)') {
      $cmd = $matches[1]
      if($filter -and $cmd.StartsWith($filter)) {
        $cmdList += $cmd.Trim()
      }
      elseif(-not $filter) {
        $cmdList += $cmd.Trim()
      }
    }
  }
 
  $cmdList | sort
 }
 
function gitRemotes($filter) {
  if($filter) {
    git remote | where { $_.StartsWith($filter) }
  }
  else {
    git remote
  }
}
 
function gitLocalBranches($filter) {
   git branch | foreach { 
      if($_ -match "^\*?\s*(.*)") { 
        if($filter -and $matches[1].StartsWith($filter)) {
          $matches[1]
        }
        elseif(-not $filter) {
          $matches[1]
        }
      } 
   }
}

At the moment the functionality is quite limited but already I find this extremely useful when working with git repositories – it has already saved me countless keystrokes throughout the day.

I have also created similar functionality for Mercurial repositories which I’ve posted about here.

There are two tools that I’ve found make PowerShell significantly easier to use. The first is PowerTab which provides IntelliSense-like autocompletion for directory paths, PowerShell commands and .NET types.

The second tool that I use is Console which is an application that can host a variety of shells including cmd.exe, bash and PowerShell.

My two favourite features of Console are its improved copy/paste support and the ability to have tabbed shells.