Emacs Redux

Return to the Essence of Text Editing

Auto-indent Your Code With Aggressive-indent-mode

| Comments

One of the things I hate the most while programming, is having to manually adjust the indentation of some code, after I’ve moved or renamed something in it. While it’s pretty easy to do such re-indent operations using commands like crux-indent-defun or advices like crux-with-region-or-buffer (you remember, crux, right?), there’s an even more efficient way to tackle the issue at hand. Enter aggressive-indent-mode.

aggressive-indent-mode’s name is a bit of a misnomer - it should probably have been named auto-indent-mode, as this is what it does. When you edit your code it will adjust the indentation automatically. It’s easier to show this than to explain it.

Here’s one example showing agressive-indent-mode enabled in emacs-lisp-mode:

And another example using cc-mode:

Provided you’ve installed the mode, enabling it for particular major modes is a piece of cake:

1
2
3
(add-hook 'emacs-lisp-mode-hook #'aggressive-indent-mode)
(add-hook 'clojure-mode-hook #'aggressive-indent-mode)
(add-hook 'ruby-mode-hook #'aggressive-indent-mode)

If you want to enable it in all major modes you can do this as well:

1
(global-aggressive-indent-mode 1)

Note that this is not going to work well with modes like python-mode and haml-mode where the proper indentation can’t be reliably determined. When global-aggressive-indent-mode is enabled it will not affect major modes listed in aggressive-indent-excluded-modes.

For more info - head over to the project’s readme.

Display the Keybinding for a Command With Substitute-command-keys

| Comments

If you ever need to show the keybinding for a particular command to the users of your package (e.g. you’re adding some tips functionality), you should avoid resisting the urge to write something like this:

1
(message "Press <C-c p p> to switch between projects.")

Why is this a bad idea? Because you might change the keybinding of the command in question (e.g. projectile-switch-project, but you might forget to update messages like this. Is there a better way? substitute-command-keys to the rescue:

1
(message (substitute-command-keys "Press <\\[projectile-switch-project]> to switch between projects"))

This will produce exactly the same message as before and you’re guaranteed the keybinding will always be in sync with the command.

Neat!

P.S. If you want to check interactively the keybinding of some command use C-h f (describe-function). Here’s an example - C-h f RET projectile-switch-project RET will produce this:

1
2
3
4
5
6
7
8
projectile-switch-project is an interactive compiled Lisp function.

It is bound to C-c p p, s-p p, <menu-bar> <tools> <Projectile> <Switch
to project>.

(projectile-switch-project &optional ARG1)

...

You can also check which command is bound to some key with C-h k.

Use Tab to Indent or Complete

| Comments

By default in Emacs the Tab key does only indentation. If some major mode provides completion of some form, you normally have to trigger it with M-Tab. In most window managers, however, this keybinding is used to switch between open windows, which makes it a bit hard to use out of the box.

There’s a simple trick to augment the default Tab behavior. Just put this in your Emacs config:

1
(setq tab-always-indent complete)

Now, when you press Tab one time it will indent and if you press it again you’ll get completion candidates. If the indentation at point is already correct you’ll get the completion candidates right away. As an added bonus - you don’t really need M-Tab anymore.

Simple and neat! One really has to wonder why this isn’t the default behavior.

Imenu-anywhere

| Comments

For the longest time Prelude included the function prelude-goto-symbol (bound to C-c i). It basically allowed you to jump to any definition in the current source file using imenu behind the curtains.

Recently I’ve found an even better option - the package imenu-anywhere. It works in a pretty similar manner but gives you the ability to jump to any definition in any currently open buffer. That’s quite handy and it greatly reduces the need to use something like etags.

As an added bonus - imenu-anywhere features helm integration.

This is a very handy package and I encourage you to give it a go!

P.S. Prelude users should simply upgrade to the latest version of Prelude (it already uses it).

My Personal Emacs Configuration

| Comments

From time to time people ask me about my personal Emacs configuration. Other just assume that I use Prelude. For a very long time my personal configuration was pretty similar to Prelude - in a way it was a staging ground for things to go into Prelude eventually (although changes would travel both ways when Prelude users suggest some cool things).

Recently I’ve decided that in the future I want to do a few things with Prelude:

  • extract as much functionality from it as possible into reusable packages (e.g. super-save and crux)
  • adopt there use-package
  • improve the support for Windows (because now I have Windows computer)

As part of these efforts I reworked my personal config into something pretty simple (it’s a single init.el file) and I’ve started experimenting with ideas for the future. Stay tuned for the results!

The config is available here. Perhaps some of you will find something useful there.

Remap Return to Control in GNU/Linux

| Comments

A long time ago I wrote about remapping Return to Control in OS X. This was the best productivity boost for my Emacs experience ever!

Recently I’ve bought a Windows ultrabook (wanted something as light as MacBook Air, but more powerful and versatile) and I’m doing most of my work there in a Xubuntu VM. The first thing I did while setting up Xubuntu was to figure out how to do the aforementioned remapping.

In my original post some people suggested the tool xcape, so I took a look at it. The tool can certainly use some documentation improvements (and pre-built packages), but it gets the job done. After you’ve installed it you just need to add the following to your login shell’s init file (e.g. .bash_profile) and you’re in business:

1
2
3
4
5
6
xmodmap -e "remove Control = Control_R"
xmodmap -e "keycode 0x69 = Return"
xmodmap -e "keycode 0x24 = Control_R"
xmodmap -e "add Control = Control_R"

xcape -t 10000 -e "Control_R=Return"

Obviously the first time around you should source .bash_profile after updating it:

1
$ . .bash_profile

This is definitely a lot more work than just clicking in the GUI of the wonderful Karabiner, but it yields the desired results and that’s what’s important at the end of the day.

Now if only there was a way to achieve the same result in Windows…

P.S. vim users will love xcape. Its default behaviour is to generate the Escape key when Left Control is pressed and released on its own.

Crux

| Comments

I’d often blog about some useful utility functions here. Pretty much all of them get included in Emacs Prelude, but I’ve decided I can do one better and extract those of them which are most useful/universal into a separate package.

This package is crux - a Collection of Ridiculously Useful eXtensions for Emacs.

You can install it from MELPA and MELPA Stable. Once this is done you just have to pick keybindings for the commands shipped with crux. I’ve suggested some keybindings here. And here’s a small configuration snippet showing how to actually bind keys to some of crux’s commands:

1
2
3
4
5
6
(global-set-key [remap move-beginning-of-line] #'crux-move-beginning-of-line)
(global-set-key (kbd "C-c o") #'crux-open-with)
(global-set-key [(shift return)] #'crux-smart-open-line)
(global-set-key (kbd "s-r") #'crux-recentf-ido-find-file)
(global-set-key (kbd "C-<backspace>" #'crux-kill-line-backwards))
(global-set-key [remap kill-whole-line] #'crux-kill-whole-line)

crux also ships with some handy advises that can enhance the operation of existing commands.

For instance - you can use crux-with-region-or-buffer to make a command acting normally on a region to operate on the entire buffer in the absense of a region. Here are a few examples you can stuff in your config:

1
2
(crux-with-region-or-buffer indent-region)
(crux-with-region-or-buffer untabify)

So, this is crux for you - simple and neat! I’d love it if you contributed more useful commands to it, so we can make it even more versatile!

Super-save

| Comments

A while back I wrote an article on saving buffers when they lose focus.

Recently I’ve packaged (an improved version of) this functionality into a tiny global minor mode called super-save.

The package is available on MELPA and MELPA Stable and enabling it is trivial:

1
(super-save-mode +1)

If you want to enable the additional feature of auto-saving buffers when Emacs is idle, add the following as well:

1
(setq super-save-auto-save-when-idle t)

If you’re like me and don’t care about the backups created by the built-in auto-save-mode, you can disable it aftewards:

1
(setq auto-save-default nil)

I’ve been using Emacs for over 10 years now and I’ve never needed the auto-created backups - I’m either very lucky or this is less useful than it’s supposed to be.

Ace-jump-mode Is Dead, Long Live Avy

| Comments

People often ask how am I navigating efficiently Emacs windows and buffers. I have the feeling they expect me to share with them some secrets that would turbo-charge common commands like C-s, M-f, C-x o, etc. I don’t, however, use those commands that much. Ever since I saw that vim’s EasyMotion has been ported to Emacs, I’ve been using that port - namely ace-jump-mode.

Basically, it allows you to navigate to every visible portion of your Emacs (buffers & windows) with only a handful of keystrokes (usually one two activate it and one or two to get where you want to go). You can see it in action in this excellent video. ace-jump served me well for years, but I’ve had a few gripes with it that were never addressed (multi-char targets, CamelCase support, etc). I would have implemented those myself, if the project was maintained at all, but alas - that’s not the case. Seems I wasn’t the only one who was frustrated with ace-jump, as the prolific Oleh Krehel reimplemented it pretty much from scratch for the purposes of his excellent ace-window library. Once I got wind of this, I managed to persuade Oleh to start distributing his rewrite as a standalone project, which he dubbed avy.

Avy features everything ace-jump does and more. Apart from the many extra features, its codebase is way cleaner and readable and Oleh is a fantastic and very responsive maintainer. So, as far as I’m concerned ace-jump is now a dead project and pretty much everyone who’s using it should try out avy instead. Their usage and interface are pretty similar, so the learning curve is non-existing. By the way, here’s avy in action:

And what about my usage of avy? Nothing fancy here - I just bind the commands I consider most important to handy keystrokes.

1
2
3
(global-set-key (kbd "C-c j") 'avy-goto-word-or-subword-1)
(global-set-key (kbd "s-.") 'avy-goto-word-or-subword-1)
(global-set-key (kbd "s-w") 'ace-window)

avy-goto-word-or-subword-1 is aware of CamelCase words and I do a lot of programming in languages that use those extensively.

avy has one more thing going for it - it’s part of the default Emacs package repo GNU ELPA, which means that you can install it right away without having to setup any third-party repositories (which you’ll probably need sooner or later).

avy and ace-window are naturally part of Prelude.

P.S. Oleh, one of those days you should rename ace-window to avy-window. :-)

JDEE Reborn

| Comments

JDEE (Java Development Environment for Emacs) used to be best way to develop Java apps in Emacs a while back. It offered a ton of cool features, like smart auto-completion and a debugger. Unfortunately at some point the development slowed down significantly and the project went in a catatonic state. There was pretty much no activity for years in the official SourceForge repo and there was also no support for features introduced in Java 5+.

Recently, however, the project migrated to GitHub and it’s now way easier to get involved. Seems that some people have already started work on updating JDEE to support modern JDKs and modern Emacs functionality.

That’s a really exciting project, as Java support has traditionally been a weakness of Emacs and I’m writing this post with the hope that more people will help make JDEE great again.

So what are you waiting for? If you’re into Java and friends (Scala, Clojure, Groovy, etc), check out the new official repo and let’s get this party started!