YASnippet, or Yet Another Snippet package just released a new beta with many new features. YaSnippet is a template system for emacs. It allows you to type an abbrevation and then trigger that abbreviation into an expansion in your buffer. Some of the new features are:

• Nested Placeholders: Nested placeholders allow you to support optional attributes or portions of your snippet. If you don’t need these optional attributes then type C-d and exit out of the snippet. This feature is heavily used in TextMate snippets, and now makes borrowing snippets from TextMate even easier. For example, the snippet below gives you a div tag and optionally allows you to specify your id.

     <div${1: id="${2:someid}"}> $0

• Menu Grouping: The YASnippets menu now supports logical grouping of snippets under the mode. For example, ruby-mode snippets are now grouped into logical areas such as collections and control structures. I don’t normally like using menus in emacs, but I find the logical grouping in lieu of the long list helpful until I have the snippets memorized.
• Multiple Prompting Mechanisms: If you have multiple snippets attached to the same tag trigger, then you will get prompted for the snippet you desire. You can specify the desired order for how you want to be prompted by setting the function list in the variable yas/prompt-functions. Some people like menus so you might want to use yas/dropdown-prompt (see the screenshot above), but my current preference is yas/ido-prompt.
• Easier Snippet Development: When working on a new snippet, you can use the command M-x yas/tryout-snippet or C-c C-t which opens a test buffer and expands your new snippet.

• Snippets within Snippets: You can now call one snippet while within the expansion of another snippet.

For more info, take a look at the YASnippet documentation.

(defun copy-line (&optional arg)
  "Do a kill-line but copy rather than kill.  This function directly calls
kill-line, so see documentation of kill-line for how to use it including prefix
argument and relevant variables.  This function works by temporarily making the
buffer read-only, so I suggest setting kill-read-only-ok to t."
  (interactive "P")
  (toggle-read-only 1)
  (kill-line arg)
  (toggle-read-only 0))
 
(setq-default kill-read-only-ok t)
(global-set-key "\C-c\C-k" 'copy-line)

See also http://www.emacswiki.org/emacs/CopyingWholeLines.

By setting the custom-file variable, you can keep those automated customizations in a separate file. Put this in your Emacs init:

(setq custom-file "~/.emacs.d/custom.el")
(load custom-file 'noerror)

Both lines are necessary. The first line tells Custom to save all customizations in the file, but does not load it. The 'noerror argument passed to load prevents errors if the file doesn’t exist. If you had existing customizations in your init file, be sure to copy them to the new custom file.

Now, go enjoy a cleaner init file. This tip is especially useful if you keep your init files under a version control system. You do keep your init files under version control, right?

It’s … a set of dotfiles extracted from my years of obsessive Emacs tweaking. It acts as a base config from which new users can get going with minimal fuss. You won’t learn Emacs from it, but it will help you get started out as it provides saner defaults and bundles a lot of really useful functionality.

I’ve been using it as my main config for quite some time now, so it’s got all the libraries I need. If you’re interested in trying out with Emacs but don’t know where to start, give this a shot. If you’re an old hand but are curious to pick up some new tricks, try out the starter kit and let me know if it’s missing some must-have functionality that you’re used to.

Give it a try:

$ git clone git://github.com/technomancy/emacs-starter-kit.git
$ emacs -q -l ~/path/to/emacs-starter-kit/init.el

I’m going to play with this on and off for the next few days and see if I can’t learn a few tricks from an emacs guru.

UPDATE: For those that don’t use Git and can’t find the ‘Download’ button on GitHub, here’s the tarball and the zipball.

I’ve tried ido in the past, but it always turned me off. Today I realized why, and I was finally motivated enough to find a fix. I am a big fan of tab-completion everywhere, so when tab-completion doesn’t work like I expect, I get upset. As it turns out, this is why I (unfairly) disliked ido-mode at first. Due to some other trickery that I would rather not go into, I was guaranteeing that <tab> in the minibuffer would always call minibuffer-complete, which broke the tab behavior in ido:

(define-key minibuffer-local-map [tab] 'minibuffer-complete)

In summary, I’m a doofus. I should probably re-investigate the need for the above mapping; it was necessary because of a global key binding that I shouldn’t have made global in the first place. Without going down that rat hole just yet, here’s my workaround for now:

(ido-mode t)
(setq ido-enable-flex-matching t) ; fuzzy matching is a must have
 
;; This tab override shouldn't be necessary given ido's default 
;; configuration, but minibuffer-complete otherwise dominates the 
;; tab binding because of my custom tab-completion-everywhere 
;; configuration.
(add-hook 'ido-setup-hook 
          (lambda () 
            (define-key ido-completion-map [tab] 'ido-complete)))

I’m going to give ido-mode a fair chance this time, and I think I’m going to like it. I anticipate growing my custom ido configurations in the near future, and ido-mode could easily make it as a package fave. Thanks Stu.

For those of you who have already realized the power of Interactive Do, what power tricks do you recommend?

Update: Flex or fuzzy matching is the ability to match any item containing the characters in the given sequence. For example, “mwc” might match a file named “my_wicked_class.rb.”

(windmove-default-keybindings 'meta)

If you invoke the command without an argument then shift is used as the prefix. I also had to place this below the turning on of pc-selection-mode because it also sets the M-up, M-down, M-left, and M-right keys.

Installation

Grab the latest js2, put it in your load-path, and configure. Full instructions. Here’s my config:

(autoload 'js2-mode "js2" nil t)
(add-to-list 'auto-mode-alist '("\\.js$" . js2-mode))
 
(setq js2-basic-offset 2)
(setq js2-use-font-lock-faces t)

(Steve, I’m one of those who like my font-lock settings, so thanks for keeping the font-lock-faces option around for us crazies.)

Features

• Indenting that works! Finally.
• Syntax highlighting that works. ‘Bout time.
• Inline warnings and syntax errors. Useful.
• Decent code folding. I like.

• Other tidbits. You’ll have to read Steve’s long-winded post for more.

A quick stab at providing a simple template facility like the one present in TextMate (an OSX editor).

The creator of smart-snippet, an extension to snippet.el, has now created the aptly titled yasnippet – Yet Another Snippet extension for emacs. It looks promising based on the screencast… I have not had a chance to play with it yet locally. The mirrored fields support looks cool though.

pastie-buffer – Posts the current buffer as a new paste at pastie.caboo.se.
pastie-region – Posts the selected region as a new paste at pastie.caboo.se.
pastie-get – Fetches the contents of a paste from pastie.caboo.se into a new buffer.

The thread also points out that the Emacs Wiki contains a list of Emacs User Locations (in text form of course). There is also a link to an Emacs Flickr tag.

Today, I am declaring .emacs bankruptcy.

Akin to email bankruptcy, I’m blowing everything away and starting over. Only as I realize a need for something is it going back in. I’m also starting with a better organization scheme. My intent is to have a .emacs file with nothing but load-path additions and requires.

Examples

Here is an early view of my .emacs as I start this process:

;;;; Ryan McGeary's emacs initialization (2001-2007)
 
;; Enable a backtrace when problems occur
;; (setq debug-on-error t)
 
;; Load paths
(add-to-list 'load-path (expand-file-name "~/.emacs.d"))
(add-to-list 'load-path (expand-file-name "~/.emacs.d/lisp"))
(add-to-list 'load-path (expand-file-name "~/.emacs.d/lisp-personal"))
 
;; Personal customizations
(require 'my-generic)
(require 'my-iswitchb)
(require 'my-carbon-emacs)
(require 'my-colors)
;; Many more to come

And here is an example of a personal customization (my-generic):

;;; Generic emacs settings I cannot live without
 
;; "y or n" instead of "yes or no"
(fset 'yes-or-no-p 'y-or-n-p)
 
;; Highlight regions and add special behaviors to regions.
;; "C-h d transient" for more info
(setq transient-mark-mode t)
 
;; Display line and column numbers
(setq line-number-mode    t)
(setq column-number-mode  t)
 
;; Emacs gurus don't need no stinking scroll bars
(toggle-scroll-bar -1)
 
;; Line-wrapping
(set-default 'fill-column 80)
 
;; Prevent the annoying beep on errors
(setq visible-bell t)
 
(provide 'my-generic)

This particular component is very likely to grow, but with the added organization elsewhere, I am more likely to refactor early and often.

Key points

• Third party packages go in ~/.emacs.d/lisp.
• My own packages go in ~/.emacs.d/lisp-personal.
• Personal customizations are broken into manageable components, and each is prefixed with “my” to avoid naming conflicts. These are placed in my ~/.emacs.d directory.
• Customization components can be compiled for speed, or commented out when not needed.

• My stress levels are reduced knowing everything has it’s own cubbyhole.

I anticipate this being a good bit of work, but I think it’s going to be well worth it. If nothing else, it makes me happier.

Your feedback, please

Who else wants to declare bankruptcy with me? What other techniques, tools, or conventions am I missing?

;; I hate tabs!
(setq-default indent-tabs-mode nil)

Now, if you also use tab completion everywhere, someday, you’ll want to actually insert a real <tab> character (ASCII 9), but won’t be able too. Quoted-insert to the rescue. Type C-q C-i to insert a horizontal tab character.

Note: Even though, I’ve aired my religious preference on this topic, my intention is not to start a war but to teach those who like spaces how to configure emacs (Yes, I’ve read the heated material on the subject).

• parenthesis – shows the matching paren
• expression – shows the entire expression enclosed by the paren, and

• mixed – shows the matching paren if it is visible, and the expression otherwise.

To obtain this behaviour, add the following to your .emacs file:

(show-paren-mode t)

Installation

First, let’s install rcodetools. I am going to assume that you already have ruby and rubygems installed.

$ gem install rcodetools

(Prefix your install with sudo if necessary on your system.)

Rcodetools is now installed under [GEM_INSTALL_DIR]/gems/rcodetools-0.7.0.0 and there is good emacs setup documentation in README.emacs, but for what I’m about to demonstrate here, you only need to install rcodetools.el. Copy rcodetools.el to somewhere in your emacs load-path and require it.

(require 'rcodetools)

Capturing STDOUT

Suppose you have a ruby script in a buffer that looks like this:

3.times { puts "Hello World!" }

Run M-x xmp and now your buffer will look like this:

3.times { puts "Hello World!" }
# >> Hello World!
# >> Hello World!
# >> Hello World!

Code Annotation

You can sprinkle annotated results in your source code by adding # => markers at the end of lines to show their values. This comment marker can be added to the end of a line automatically by running comment-dwim twice (M-; M-;).

If you had a script that looked like this:

def fib(n)
  n < 2 ? n : fib(n - 1) + fib(n - 2)
end
 
fib(2)           # =>
fib(11)          # =>

After running M-x xmp, the last two lines of your buffer will look like this:

...
fib(2)           # => 1
fib(11)          # => 89

Summary

I find this package pretty cool and I wish I knew about it sooner. This is going to change the way I write and test my one-off ruby scripts.

Xmpfilter can also be used to generate Test::Unit assertions and RSpec expectations automatically, but I leave that as an exercise for the reader. Find more information on xmpfilter.

(Rcodetools also ships with Vim support, and TextMate users get bundled xmpfilter integration for free.)

Context Sensitive Switching Between Rails Buffers

The rails framework espouses convention over configuration, therefore you can typically make assumptions that a method named edit in your controller is going to display a view that can be found under app/views/<controller name>/edit.rhtml. Additionally, due to the frameworks conventions there are a number of other files that are generally associated with a specific controller or model. M-Shift-up will take you directly to the primary file that is associated with the code location at point. M-Shift-down provides a list of other potential file options from which you can choose. For example, the screenshot below shows the results of pressing M-Shift-down when point is in the show method of the CompanyController.

Snippet Functionality

This functionality is actually derived from the
snippet.el package that provides another take on templating in emacs that closely mimics the templating functionality that is provided in TextMate. In the case of emacs-rails mode, these templates are tied to abbreviations. So if I type tcl and then tab while in a migration file, then a new line will be added to the table creation and my point will be placed in the area of the title of the column. When I am done updating the column name I can tab and I will be able to enter the type of column. I tab once again an I am out of the snippet editing mode. I think the rails-mode snippet integration is nicely done.

Invocation of Rake with Task Name Completion

C-c C-c r will prompt you in the minibuffer for the rake task that you want to run. Output of the rake task is then shown in a separate *ROutput* buffer. C-c / will toggle the showing or hiding of the output buffer. Rake tasks specific to testing are actually invoked via a separate command, C-c C-c t.

For users that like to use the mouse and menus, all of the commands listed above can be accessed from the menu. I would also recommend taking a look at the two screencasts (here and here) that show emacs-rails mode in use, although there have been a number of changes to the package since the screencasts were made.

On blank line, delete all surrounding blank lines, leaving just one.
On isolated blank line, delete that one.
On nonblank line, delete any immediately following blank lines.

Before:

After:

Emacs version 22 includes GTK+ toolkit support, enhanced mouse support, a new keyboard macro system, improved Unicode support, and drag-and-drop operation on X, plus many new modes and packages including a graphical user interface to GDB, Python mode, the mathematical tool Calc, the remote file editing system Tramp, and more.

You can get it here.

So, what do people use on larger projects? Believe it or not, there are actually GNU conventions for styling these files, and emacs includes an add-log package to help adhere to these conventions.

The command add-change-log-entry-other-window (C-x 4 a) automatically adds a new entry to the closest change log file found up the parent directory hierarchy. If none exists, a new change log file is created in your current directory, and the formatting is organized for you:

The command vc-update-change-log (C-x v a) finds the change log file and add entries from the recent version control logs. Apparently, this only works with RCS or CVS. For subversion, you can try vc-comment-to-change-log (Emacs 21) or log-edit-comment-to-change-log (Emacs 22), but this might require some customization to suit you.

To change the email address listed in your change log entries, edit the user-mail-address variable. To change the default change log file name, edit the change-log-default-name variable.

(setq user-mail-address "ryan@example.com")  ;; default: user@host
(setq change-log-default-name "CHANGELOG")   ;; default: ChangeLog

Some might say that keeping a ChangeLog file is defeated by public subversion repositories. I tend to agree for most circumstances, but there are some cases where a local, easily readable ChangeLog file is a good idea. Besides, it’s the cool thing to do.

The emacs manual has more information on change logs.

2 — skip anything less than error
1 — skip anything less than warning, or
0 — don’t skip any messages.

Note that all messages not positively identified as warning or info are considered errors.

psvn mode is similar to pcl-cvs for the Concurrent Version System (CVS). It is a frontend to the subversion client (svn). M-x svn-status will prompt you for the location of your working directory (or subdirectory). Once it is entered a new buffer, *svn-status* , will open up with a status of all files within that directory and any subdirectories. It essentially runs svn status -v. This view of your working copy of the repository shows the status of the files. You have the option of hiding unchanged files with the command _. You can mark multiple files to be committed, and then commit them with the command c which will in turn bring up an edit window where you can write the comment associated with your commit. Additionally, there are commands for diffing files, editing properties, and just about every other interaction you have with subversion. Be sure to check the following options:

• svn-status-verbose – Setting this to nil will make M-x svn-status run without the -v option at the command line.

• svn-status-hide-unmodified – Setting this automatically performs the toggle that you can do with _ when in the *svn-status* buffer, so that you only see files with a status that has changed in your working directory.

The package and its commands become an extension of the way you work with your files within emacs. It’s one of my favorites because it doesn’t get in the way of your normal process.

XKeymacs is a keyboard utility to realize emacs-like usability on all windows applications. With XKeymacs you can use emacs keybindings with any windows application. You can create a keyboard macro and assign any shortcut key too. You also get bash-like command completion in your DOS shell.

This may very well void the need for Emacs Keybindings in MS Word.

I only played with it briefly as I’m no longer Windows-bound, but my initial impressions were good. Here is a more comprehensive review of XKeymacs.

Once you install it, the bindings are global – they work in Windows Explorer, Microsoft Word, Excel, in text-boxes and combo-boxes – everywhere. As for applications that provide their own readline bindings (such as Gnu Emacs on Windows), you must setup key-binding exceptions…

What I despise even more is that some editors seem to be incapable of determining the difference between a DOS and Unix file. There’s nothing worse than finding a once, perfect Unix file corrupted by a small section of lines with CRLFs while the rest of the file keeps only LFs. Most of the time, the blame can be placed on one’s editor configuration, but I also blame some editor defaults for not at least maintaining the format that the file was opened in. To be fair, most power-editors like emacs, vim, TextMate, etc behave “correctly” by default and keep the format that the file was opened in, but many others (unnamed) do not.

There’s not a whole lot we can do to avoid these problems without hounding our peers, but there are ways to fix these problems after they’re found.

Let’s fix the nastier problem first. When you find a file corrupted with half LFs and half CRLFs, strip out the ^M (CR) characters with a quick search and replace. Run M-% (query-replace) and substitute C-q C-m with nothing. C-q runs quoted-insert and is useful for inserting control characters (e.g. ^M, entered as C-m). Afterwards hit the exclamation point (!) to tell query-replace to replace all matches with no questions.

Other times, you will run into DOS formatted files and will just want to convert them to Unix format for consistency sake. To do this, open the buffer and run C-x <RET> f then enter unix or undecided-unix when prompted for the new coding system. This runs set-buffer-file-coding-system and the result is very similar to running dos2unix myfile.txt at the command line.

¹ CR is Carriage Return. LF is Line Feed (aka Newline).