From the docs:

Dizzee is a pleasant way to manage your project’s subprocesses in Emacs.
You have a project.
In order to get an instance running and start working, you have to manually launch say… 4 processes in 4 different shells.
This is Not Fun.
Thankfully it is also a definable, repeatable process – which means that we can Use Programming.
At worst, this is More Fun than doing it yourself every time.

This all came about when I started my current job – of the three product stacks I work on, none can be run from source without launching multiple processes in separate shells. Terminator helps (and is generally awesome) but being able to start work on a bug all with one command, and build in code reloading without having to build it into the source & go through the process of getting the relevant buy-in for that, was a massive win.

Bugs/feature requests & docs via github.

Enjoy.

Love regards etc

(defmacro dotfile (filename)
  "Define the function `filename' to edit the dotfile in question"
  (let ((filestr (symbol-name filename)))
    `(progn
       (defun ,(intern filestr) ()
         ,(format "Open %s for editing" filestr)
         (interactive)
         (find-file ,(concat "~/" filestr))))))

With which we can define a M-x .emacs function with:

(dotfile .emacs)

Love regards etc

So thanks to this, C-M-; now colonizes the line and leaves me happily where I was

 
(defun colonize ()
  "For languages that insist on putting a colon at the end of a line,
do that. But stay where you're thinking is at."
  (interactive)
  (save-excursion
    (move-end-of-line nil)
    (insert ";")))
 
(global-set-key (kbd "C-M-;") 'colonize)

Love regards etc

Add to this the merry dance you have to go through to ammend commit messages in Mercurial and things get even worse. (Oh how I’d love for hg to implement something similar to git’s $ git commit –amend )

Hence, a Pre-transaction-commit hook for hg that will ask me if I’m sure I want to commit without an issue number. If want to commit anyway, it’s just two extra keystrokes, and saves a whole lot of rollback/apply nonsense.

#!/usr/bin/env python
import os
import re
import subprocess
import sys
 
cmd = subprocess.Popen(['hg', 'log', '-vr', os.environ['HG_NODE']],
                       stdout=subprocess.PIPE).communicate()[0]
msg = cmd.split('description:')[1]
issue_regexes = [
    # Trac
    r'#\d+',
    # Redmine
    r'fixes #\d+',
    r'refs #\d+',
    ]
if not filter(lambda x: re.search(x, msg), issue_regexes):
    print "No issue ref or fix... message is:"
    print msg
    sys.stdout.write("Continue? [y/n] ")
    resp = raw_input().lower()
    if resp == 'n':
        sys.exit(9)

Then add the following to your project’s .hg/hgrc:

[hooks]
pretxncommit = path/to/your/pretxncommit.py

Saving you endless embarrassment:

davidmiller@pascal:~/src/buggy_repo$ hg commit -m "A context-less void"
No issue ref or fix... message is:
 
A context-less void
 
 
 
Continue? [y/n] n
transaction abort!
rollback completed
abort: pretxncommit hook exited with status 9

Love regards etc

So, here are the steps you need to turn OOTB Emacs into the perfect environment for working on Javascript:

Auto-completion

Fizzing!

First up, you’re going to want decent auto-completion, so install the straightforwardly named auto-complete-mode. Due to some mode-name aliasing that goes on in the Emacs23 javascript mode, You’ll need to make sure it can find the relevant Javascript dictionary so

cd path/to/auto-complete/dict
ln -s javascript-mode js-mode

and then add to your .emacs:

(add-to-list 'load-path "~/path-to/auto-complete")
; Load the default configuration
(require 'auto-complete-config)
; Make sure we can find the dictionaries
(add-to-list 'ac-dictionary-directories "~/emacs/auto-complete/dict")
; Use dictionaries by default
(setq-default ac-sources (add-to-list 'ac-sources 'ac-source-dictionary))
(global-auto-complete-mode t)
; Start auto-completion after 2 characters of a word
(setq ac-auto-start 2)
; case sensitivity is important when finding matches
(setq ac-ignore-case nil)

You now have auto-completion for all variable names in all open Javascript buffers, as well as for standard syntax words (setTimeout, parseInt, onFocus etc).

Snippeting

Not content with that, we’ll also want some kind of intelligent snippet package right – how many times do you really want to type all those semicolons and curly braces? Once is good for me.

The excellent Yasnippet provides this (check out the youtube demo if you’ve not come across it before)

Once you’ve got that downloaded and installed, you’ll want some Javascript snippets to load in, the ones I use, for standard Javascript and jQuery can be downloaded from here, and then the directory provided by that tarfile needs to go in yasnippet/snippets/text-mode

So for our .emacs:

(add-to-list 'load-path "~/path/to/yasnippet")
;; Load the library
(require 'yasnippet)
(yas/initialize)
;; Load the snippet files themselves
(yas/load-directory "~/path/to/yasnippet/snippets/text-mode")
;; Let's have snippets in the auto-complete dropdown
(add-to-list 'ac-sources 'ac-source-yasnippet)

Syntax Checking

Whoops...

One of the problems with Javascript programming is that the feedback loop for syntax errors is *slow* – if you’re working with the web you have to wait for a whole pageload. So we’ll want on-the-fly error checking.

Kevin Turner originally wrote Lintnode, which runs a lighthweight node.js server that passes your file to Douglas Crockford’s JSLint to integrate with Flymake – the Emacs solution for on-the-fly syntax checking. The fork I’m currently maintaining at Github contains some enhancements such as automatic initialization and JSLint options passed from Emacs that the original has yet to merge in. Given that JSLint frequently complains about things that you might like it to er, not complain about, the ability to change the options with the lintnode-jslint-excludes variable makes this far more useable.

So:

Install node.js and npm (The package manager for node)

Get lintnode and the dependencies

git clone https://github.com/davidmiller/lintnode.git
cd lintnode
npm install express connect-form haml underscore

Then we need this in our .emacs:

(add-to-list 'load-path "~/path/to/lintnode")
(require 'flymake-jslint)
;; Make sure we can find the lintnode executable
(setq lintnode-location "~/path/to/lintnode")
;; JSLint can be... opinionated
(setq lintnode-jslint-excludes (list 'nomen 'undef 'plusplus 'onevar 'white))
;; Start the server when we first open a js file and start checking
(add-hook 'js-mode-hook
          (lambda ()
            (lintnode-hook)))

Syntax errors will now be given a red background without having to leave the comfort of Emacs.

Even better, if we install the Flymake Cursor package, we get the error message in the minibuffer when the cursor is on a line with an error.

Easy Mistake!

Get the source from http://www.emacswiki.org/emacs/flymake-cursor.el and then add to your .emacs:

(add-to-list 'load-path "~/emacs/minor-modes")
;; Nice Flymake minibuffer messages
(require 'flymake-cursor)

Edit:

As Jesse and Magnar point out in the comments, it’s probably a better idea to not exclude ‘undef from the jslint errors, but rather to declare global variables at the top of your .js file

 /*global $ */

This way you can let jslint know about other libraries you are using, but still get the checks for undefined variables in your own code.

Code folding

Underscore outline

Especially if you’re dealing with large projects, the ability to hide portions of code can be great for maintaining focus. Emacs comes with this built in, but you have to enable it, so returning to our .emacs:

(add-hook 'js-mode-hook
          (lambda ()
            ;; Scan the file for nested code blocks
            (imenu-add-menubar-index)
            ;; Activate the folding mode
            (hs-minor-mode t)))

This means that when your cursor is in the function…

var Foo = 42;
addFoo = function(num){
    // Let's add the meaning of life to
    // our `num` - it'll be fun!
    var meaningful;
    meaningful = num + Foo;
};

… and you M-x hs-hide-block, the function turns into:

Var Foo = 42;
addFoo = function(num){...};

To my taste the default keybinding of C-c @ C-h to hide blocks is somewhat perverse, so I’d recommend this in your .emacs:

;; Show-hide
(global-set-key (kbd "") 'hs-show-block)
(global-set-key (kbd "") 'hs-show-all)
(global-set-key (kbd "") 'hs-hide-block)
(global-set-key (kbd "") 'hs-hide-all)

YMMV.

Javascript Console

Having a REPL for the language you’re working with close to hand is basically required for me to enjoy working with it. Now that we’ve installed node.js, though, we can have us a Javascript console inside Emacs with js-comint…

Once you’ve grabbed the file, your .emacs should have:

(add-to-list 'load-path "~/path/to/js-comint")
(require 'js-comint)
;; Use node as our repl
(setq inferior-js-program-command "node")
 
(setq inferior-js-mode-hook
      (lambda ()
        ;; We like nice colors
        (ansi-color-for-comint-mode-on)
        ;; Deal with some prompt nonsense
        (add-to-list 'comint-preoutput-filter-functions
                     (lambda (output)
                       (replace-regexp-in-string ".*1G\.\.\..*5G" "..."
                     (replace-regexp-in-string ".*1G.*3G" ">" output))))

You can then run a Javascript REPL with M-x run-js and also send portions of files by selecting them and then running M-x send-region. Neat.

By way of conclusion

There are a few other tweaks that make my Javascripting just that little bit nicer, but they’re more personal Emacs setup than anything specific to Javascript. So, there you have it, the perfect Javascript editing environment.

Love regards etc

This mode provides integration with the django management commands within emacs, as well as test integration, a minor-mode with syntax highlighting for editing templates, will determine whether you are using Fabric or Buildout, as well as much more!

This mode is under active development, so please file any bugs at the Github page, and feel free to provide any feedback/feature requests etc.

Current features include:

• Run dev server in an emacs buffer [C-c C-p r]
• * Checks to see if runserver_plus is available
• * If not uses in-built runserver
• Jump to current project in browser (start server if required) [C-c C-p b]
• Run test case at point in buffer [C-c C-p t]
• Run tests for current app in buffer [C-c C-p t]
• Run Syncdb on current project
• Management commands for current project in interactive buffer
• South integration – run south convert, schemamigration, migrate
• Run django shell in buffer [C-c C-p s]
• * Checks for shell_plus
• * If not defaults to shell
• Fabric integration [C-c C-p f]
• Startapp and dumpdata on current project within emacs
• Database integration with Emacs sql-mode interactive buffer [C-c C-c d
• Django Template minor mode with syntax highlighting for django

template tags

• Snippet collection for django
• generate tags table for project
• run manage commands in interactive buffer
• Buildout integration
• Generate TAGS table for project to enable quick navigation
• Jump to template at point or from editing view [C-c C-p g t]

Grab it while it’s hot!

This being Emacs though, the natural solution to any irritation is to program your way out of it. M-x regexp-revert let’s you enter a regexp, and then reverts any buffer with a file location matching that regexp to the file’s current state on disk.

(defun regexp-revert (regexp)
  "Revert all buffers whose path matches regexp"
  (interactive "sPath Regexp: ")
  (dolist (buffer (buffer-list))
    (if (string-match-p regexp (or (buffer-file-name buffer) ""))
        (progn
          (set-buffer buffer)
          (revert-buffer nil t)
          (message "Reverting %s" (buffer-file-name buffer))))))

Love regards etc

Particularly with large test suites though, the speed increase is too large to go unnoticed (In my projects normally in the region of 150% YMMV).

And your tests can never be too fast right?

One solution to this is to only use the coverage test runner in a seperate management command. That way you always have access to the stats, but your ‘regular’ test run doesn’t take the performance hit.

Not only that, but you can also run the coverage stats on your continuous integration server once every few hours for a consistently recent picture of how your coverage is looking.

The code itself is nothing dead simple, just subclasses the django BaseCommand class and then fetches the right test runner:

"""
Run our tests with coverage turned on
"""
import sys
 
from django.core.management.base import BaseCommand
 
class Command(BaseCommand):
    """
    We totally want to get coverage details, but that's so slow!
    """
    option_list = BaseCommand.option_list
    help = "Run our tests with coverage turned on"
    args = "[appname ...]"
 
    requires_model_validation = False
 
    def handle(self, *tests, **options):
        """
        Actually do the test run
 
        Arguments:
        - `*tests`: test labels
        - `**options`: passed opts
        """
        verbosity = int(options.get('verbosity', 1))
        interactive = options.get('interactive', True)
        mod = __import__("django-test-coverage.runner")
        failures = mod.runner.run_tests(tests, verbosity=verbosity,
                                        interactive=interactive)
        if failures:
            sys.exit(bool(failures))

This then needs to live somewhere in an a management dir of one of your installed apps…

yourproject/yourapp/management/commands/coverage.py

…and you’ll need to

$ easy_install django-test-coverage

So that the test runner is there in your environment.

Grab the raw file here.

Alternatively you could patch django itself. Until they merge those changes though, I’ll be sticking with the seperate command.

1
2
3
4
5
6
7
8
9

#!/bin/bash
LATEST="http://build.chromium.org/f/chromium/snapshots/Linux/"`curl http://build.chromium.org/f/chromium/snapshots/Linux/LATEST`"/chrome-linux.zip"
wget $LATEST
unzip chrome-linux.zip
rm chrome-linux.zip
if [ -x ~/builds/chrome-linux/ ]; then
    rm -rf ~/builds/chrome-linux/
fi
mv chrome-linux ~/builds/

You’ll need to make the directory it’s going to download to.

$ mkdir ~/builds

Then add as a cron job to run every night && daily updates will come down the pipes!

We must plan for freedom, and not only for security, if for no other reason than that only freedom can make security secure.

Karl Popper – The Open Society and its Enemies