One thing that probably fewer people know is that once Magit is installed, it establishes automatically several keybindings in the global keymap1 that allow you to interact with Magit from any Emacs buffer in 3 different ways:
magit-status) - that’s the way in which most people use Magit.2 You get a dedicated Magit buffer where you can invoke all sorts of commands for everything that you can imagine (e.g. pulling, pushing, staging, committing, branching). Generally this seems to be the best way to work with multiple files. I’m pretty sure all of you are familiar with this way to use Magit, as it dates back to the earliest days of the project.
magit-dispatch) - that’s pretty much the same as
magit-status, but you get the opportunity to trigger a Magit command directly from the minibuffer. One can argue that’s a (slightly) more effective way to work if you know it advance what you want to do (e.g. pressing
C-x M-g l lwill display the git log).
magit-file-dispatch) - that’s the way to invoke Magit commands on the current file (e.g.
blame) and that’s the hero of today’s article.
I’ve noticed that for some reason many people don’t use
magit-file-dispatch much, which seems like a wasted opportunity as it provides the
fastest way to do common things like:
C-c M-g b)
- stage the current file (
C-c M-g s)
- commit the current file (
C-c M-g c)
- show the git log for the current file (
C-c M-g l)
- show the diff for the current file (
C-c M-g d)
I hope you’ll agree those are pretty handy commands.
magit-file-dispatch offers other commands as well, but let’s stick to the
essential ones today. One small improvement that you can do in terms of ergonomics is to map
C-c g instead:
(global-set-key (kbd "C-c g") 'magit-file-dispatch)
The reasoning for this is pretty simple - it’s much easier to use
C-c g than
C-c M-g. Unfortunately, there’s a strong Emacs tradition forbidding packages
to utilize directly such keybindings (they are reserved for user keybindings), so Magit settles for the next best thing by default. You, however, have the power
to do anything you want with your keybindings.
As a side note - if you’re manually configuring Magit’s keybindings you can stop doing this:
;; commonly found in the wild (use-package magit :ensure t :bind (("C-x g" . magit-status) ("C-x M-g" . magit-dispatch) ("C-c M-g" . magit-file-dispatch)) ;; should be just (use-package magit :ensure t :bind ((("C-c g" . magit-file-dispatch))
If for some reason you don’t like the default Magit keybindings, you can disable them via
I have to admit that for a very long time I’d use only
C-x g) and I’d go for the file commands from Emacs’s built-in
C-x v g, a command similar to
magit-blame), just because I’ve been using Emacs since before the
creation of Git (and respectively Magit). While the built-in
package is nice (and VCS-agnostic), Magit is way nicer when it comes
to Git support, so I’m glad I eventually managed to shed my old habits.
Magit probably has the best documentation of any Emacs package, but the problem with having a great documentation and lots of features is that someone has to do a lot of reading. Consider this article a cheatsheet of sorts. That’s all I have for you today. I hope you’ve learned something useful! Feel free to share in the comments how/when do you use Magit’s 3 modes of operations.