Musings of a Software Engineering Student

Dired is Emacs’s very powerful directory browsing and management package. To use it, just type ‘C-x d’ and select a directory; the directory will be displayed in a dired buffer. In this dired buffer, you can mark files either with ‘m’ or by more advanced option, such as by regexp. You can perform very powerful commands such as renaming groups of files by regexp. Dired is actually a huge package, so I’ll only go into a few of the most useful parts of it here; you really should read the manual on it.

Dired can perform operations on either individual files or groups of files that you have marked. The main ways of marking files are by selecting individual files and pressing ‘m’ (’u’ unmarks), or ‘% m’, which prompts for a regexp and matches all files matching that regexp. There are also options for marking temporary files, all directories, symlinks, etc.

Dired also lets you operate on either the current file, if no files are marked, or all marked files. The most useful operation is ‘Q’, which does a query-replace on all selected files. You can copy or move groups of files using ‘C’ and ‘R’. You can also execute shell commands on them, using !. This prompts you for a shell command to execute; if you say something without a ‘*’, such as just ‘cat’, it will run the shell command and display the output in a different buffer. Otherwise, a ‘*’ in the command will be replaced with the filenames.

Like I said, there is a huge amount to Dired, and so you should explore it on your own to find out what is available. If you have menus enabled, you can explore those to find out some of the options.

There are also two additional packages that you probably want, both of which come with GNU Emacs. Dired-x adds additional functionality to dired. Really, I mostly just use it for it’s ability to provide default shell commands to execute on files, but this is enough (actually, looking at the documentation, there’s a few other things I use that are actually from it. Just goes to show how well it integrates with dired). To enable dired-x features, add the following to your initialization file:

(require 'dired-x)

The other package you will want to install is wdired, which allows you to edit dired buffers and have the changes reflected in the filesystem. Once you enter wdired-mode, you can edit filenames using all you emacs commands, and they will be saved - including into any subdirectories added by adding ‘/’ to the filepath. If you set the permissions like I do, you can also edit the permissions. You need some way to get to wdired-mode from dired, so add the following to your .emacs file to be able to just press ‘r’ in dired mode. Once you are finished in wdired-mode and want to save your changes, simply do ‘C-x C-s’ like you are saving a regular buffer and you will switch back to dired.

(require 'wdired)
(setq wdired-allow-to-change-permissions 'advanced)
(define-key dired-mode-map	      	      (kbd "r")		'wdired-change-to-wdired-mode)

I use dired a lot, and so find it very annoying when my dired buffers get out of sync with my filesystem. I help fix this problem using the following pieces of advice around the major buffer-switching and buffer-displaying code. Once switching or displaying the buffer, it refreshes the buffer contents if it is dired-mode. This isn’t perfect - if the filesystem gets out of sync while you are in the dired buffer, it will remain out of sync until you switch to a different buffer - but I haven’t had problems with that so far.

(defadvice switch-to-buffer-other-window (after auto-refresh-dired (buffer &optional norecord) activate)
  (if (equal major-mode 'dired-mode)
      (revert-buffer)))
(defadvice switch-to-buffer (after auto-refresh-dired (buffer &optional norecord) activate)
  (if (equal major-mode 'dired-mode)
      (revert-buffer)))
(defadvice display-buffer (after auto-refresh-dired (buffer &optional not-this-window frame)  activate)
  (if (equal major-mode 'dired-mode)
      (revert-buffer)))
(defadvice other-window (after auto-refresh-dired (arg &optional all-frame) activate)
  (if (equal major-mode 'dired-mode)
      (revert-buffer)))

That’s all the customizations I have for dired currently, but there are still other packages that don’t currently come with Emacs that customize it further, such as dired+. I’d recommend going here and looking for further customizations you like, as well as reading the dired manual to find more information on it.

Ibuffer is a massive improvement on the buffer-menu function which is brought up by C-x C-b.It allows dried-like manipulations of your buffers, as well as font locks and sorting. It’s actually better than buffer-menu in pretty much every way, so if you haven’t switched to using it instead, I would highly recommend it. One of the more useful things it lets you do are: file buffers by major-mode, and then performing a replace-regexp on all marked files. You can select buffers by major mode using %m, and Q with then start a query-replace.

Another useful feature of ibuffer is it’s filtering, with ‘/’ as a prefix. Once you open ibuffer, you can filter the results down and operate on subgroups of buffers. For example, /n emacs will only show buffers in with ‘emacs’ in the buffer-name. You can also change the sort order with ’s’. Like Dired, * and % prefixes work for marking buffers.

Setting ibuffer up is relatively easy, although there is a ton of configuration you can do if you want. I’ll tell you about what I do, which is fairly minimal, but M-x customize-group ibuffer will give you all the ways to customize ibuffer. To use ibuffer instead of buffer-menu, add the following to your initialization:

(require 'ibuffer)

This just loads ibuffer. It comes with GNU Emacs, so you should already have the library without having to download it.

(setq ibuffer-default-sorting-mode 'major-mode)

This options control how lines in the ibuffer window are grouped. By specifying the sorting mode as ‘major-mode, I indicate that I want ibuffer to group buffers of the same type together. Another common sorting order is ‘recency, which orders them from most recently viewed to last viewed. Other options include ‘lexographic, ‘buffer-size, and ‘file-name.

(setq ibuffer-always-show-last-buffer t)
(setq ibuffer-view-ibuffer t)

These lines specify to ibuffer which buffers should be in the ibuffer menu. The first line specifies that it should always show the last buffer we were in, even if it would usually hide it. The second line specifies that the *Ibuffer* buffer itself should be in the buffer list - I just like having a complete list of my buffers to start with.

(global-set-key  (kbd "C-x C-b")        'ibuffer-other-window)

Since ibuffer is so much better than buffer-menu, you should just replace the C-x C-b keybinding to call ibuffer instead of buffer-menu.

I added another package back to my emacs configuration: yasnippet. Yasnippet is supposed to be based off of TextMate’s snippet system, which I have never used but have heard it is quite good. Yasnippet allows you to define your own ’snippets’ which are inserted into your file when you type a certain phrase and hit the trigger key, which is defaulted to tab. For example, in c, if you type ‘if‘, this gets expanded to

if (__)
{
 
}

Where your point is on the _. Once you finish inserting the condition, you can press TAB again to rotate to the next spot defined in the snippet - in this case, the body of the if statement.

These snippets are all kept in a directory as text files, in a folder heirarchy of modes. For example, to modify that if snippet, you would modify the “snippets/text-mode/cc-mode/if” file in your snippets folder. If you just open it up, you will see:

#name : if (...) { ... }
# --
if (${1:condition})
{
    $0
}

The #’s are just comments, and the rest of the snippet will be inserted, with the $’s being the location where the TAB goes to, with it going from $1 to $2 to … to $0. This snippet will be called by the trigger of ‘if’, which is the file name. For more information on editing snippets, see this.

To add yasnippet to your emacs startup, add the following to your init file:

(require 'yasnippet)
(yas/initialize)
(yas/load-directory "~/.emacs.d/yasnippet-0.5.10/snippets")

Where in the call to yas/load-directory you put the location of your snippets folder.

Some more additions to my .emacs file (actually, my init.el file now. I decided it was easier to be able to add my entire .emacs.d directory to source control, and keep all of my customizations in it). Most of these were from my old config files - It turns out there’s a reason I had most of that stuff. I’ll just keep re-adding stuff from them if I need it, it turns out I had a fairly comprehensible structure that allows me to easily find specific customizations I had.

(require 'ansi-color) (add-hook 'shell-mode-hook 'ansi-color-for-comint-mode-on)
(setq comint-prompt-read-only t)
(shell)

A few more customizations to my shell configuration. The first line adds colours, as well as fixing the issues I mentioned last time. I had this in my old .emacs file, but did not realize it was what fixed shell-mode to be readable - part of the reason I started over I suppose, to better understand all of my customizations. The last line just starts a shell buffer - since I primarily use the shell from emacs, I always open one anyway. This just saves me from doing it manually.

(setq default-major-mode 'text-mode)
(add-hook 'text-mode-hook 'flyspell-mode)
(add-hook 'text-mode-hook 'visual-line-mode)
(defadvice ispell-command-loop (before ispell-reverse-miss-list activate)
  "reverse the first argument to ispell-command-loop"
  (ad-set-arg 0 (reverse (ad-get-arg 0))))

I added a few things to make writing this blog and other text documents easier on myself. There are pretty much no downsides to setting the default major mode to text instead of fundamental. While in text mode, I also want spellchecking and line wrapping based on my frame size. The advice is something I picked up from the internet somewhere(actually, after investigating, from here), which reverses the order in which ispell makes suggestions. This tends to offer me better suggestions than just the normal order, for whatever reason.

(require 'uniquify)
(setq uniquify-buffer-name-style 'reverse)
(setq uniquify-separator "/")
(setq uniquify-after-kill-buffer-p t)
(setq uniquify-ignore-buffers-re "^\\*")

Uniquify is an built-in emacs package that renames buffers when you open two files with the same name. In the default case, they will merely be numbered, so for example you would have a .emacs buffer and an .emacs<2> buffer. Uniquify will append part of the file path to the file, so instead you’d have .emacs/nflath and .emacs/emacs buffers. uniquify-buffer-name-style and uniquify-separator control how the buffer names are created; describe-variable uniquify-buffer-name-style in order to see all the possible options. uniquify-after-kill-buffer-p controls whether or not buffers are renamed when other buffers were killed: When set to t, when one of the about duplicate .emacs buffers is closed, the other will rename itself to .emacs. The last line specifies not to perform this for special buffers, such as *scratch*

(defun insert-strong-tags ()
  "Inserts <strong></strong> around the word at point"
  (interactive)
  (save-excursion
    (re-search-backward "\\s ")
    (forward-char 1)
    (insert "<strong>")
    (forward-char 1)
    (re-search-forward "\\s \\|$")
    (if (not (eq (point) (point-max)))
	(backward-char 1))
    (insert "</strong>")))
(global-set-key (kbd "C-c i s") 'insert-strong-tags)

I actually wrote this function while writing this blog post. This is one of the great things about emacs: You can immediately solve inefficiencies once you notice them. This function will insert strong tags around the word you are currently on, leaving the point at the same location. This is great when you forget to add an opening tag to the beginning of the word, or are noticing an error you made afterwords and just need to add the tags.

(global-set-key (kbd "C-a") 'back-to-indentation)

I used to have C-a bound to switch between going to the beginning of the line and back to the indentation, but I realized I pretty much never wanted to go to the actual beginning of a line. I rebound C-a to what usually M-m because it’s much easier to type.

(global-set-key (kbd "C-c j") 'join-line)

A useful function that doesn’t have a default keybinding, so I provided one

(add-hook 'before-save-hook 'delete-trailing-whitespace)
(set-face-attribute 'default nil :height 80)
(column-number-mode)

The first of these customizations will delete trailing whitespace from files every time I save. I really, really hate it when I press C-e and am not at what I want to edit, and I haven’t ever encountered a situation where I need to keep trailing whitespace, so I just automate the process of removing it. The second line just sets the size of the font; you should customize this to your liking, depending on your monitor’s resolution. On some versions and monitors, I’ve had to have this be at 90; others I could set the size to 60 without any problems. column-number-mode puts the current column number on the mode line, which I like to know.

I have made a few more customizations, but they’re big enough to warrant separate posts.