etest lets you define tests in a domain specific, hierarchical
manner and gather results in a simple, structure of the same shape.

• Read the manual here.
• Get it like this: git clone http://repo.or.cz/r/ETest.git etest
• Comment on ETest at the wiki.

(defvar *my-emms-bindings*
  '(("n" "emms-next")
    ("p" "emms-previous")
    ("s" "emms-stop")
    ("P" "emms-pause")))

(stumpwm:define-key stumpwm:*root-map* (stumpwm:kbd "m")
  (let ((m (stumpwm:make-sparse-keymap)))
    (map nil #'(lambda (x)
                 (stumpwm:define-key m (stumpwm:kbd (car x))
                   (concat "exec emacsclient -e '(" (cadr x) ")'")))
         *my-emms-bindings*)
    m))

Which (by default) gives you:

• C-a m n - next
• C-a m p - previous
• C-a m s - stop
• C-a m P - pause

Anyway, the video makes for a good tutorial should you be looking to get into org.

emms is the emacs multimedia system and in true emacs fashion its very configurable and very powerful.

This screenshot shows what mine looks like at the moment. Here is the portion of the code that should get you started with customising the look and feel.

The columns (in the playlist) are play count, title, artist, last play time and album. The buffer could do with a header line I suppose.

Warning: I don't know if setting emms-track-description-function is the right thing to do as it's not just the playlist that uses it. If I find it isn't I'll follow up.

  (setq emms-browser-info-genre-format "%i● %n"
        emms-browser-info-artist-format "%i● %n"
        emms-browser-info-album-format "%i◎ %n"
        emms-browser-info-title-format "%i♪ %n")

  (setq emms-last-played-format-alist
        '(((emms-last-played-seconds-today) . "Today at %H:%M")
          (604800                           . "%a at %H:%M")
          ((emms-last-played-seconds-month) . "%d")
          ((emms-last-played-seconds-year)  . "%m-%d")
          (t                                . "")))

  (defun prettyfy-string (string &optional after)
    "Strip starting and ending whitespace and replace any chars
after AFTER with '...'"
    (let ((replace-map (list
                        (cons "^[ \t]*" "")
                        (cons "[ \t]*$" "")
                        (cons (concat "^\\(.\\{"
                                      (or (number-to-string after) "10")
                                      "\\}\\).*")
                              "\\1…"))))
      (dolist (replace replace-map)
        (when (string-match (car replace) string)
          (setq string (replace-match (cdr replace) nil nil string))))
      string))

  (defun phil/emms-info-track-description (track)
    "Return a description of the current track."
    (let ((artist (emms-track-get track 'info-artist))
          (title (emms-track-get track 'info-title))
          (album (emms-track-get track 'info-album))
          (last-played (or (emms-track-get track 'last-played) '(0 0 0)))
          (play-count (or (emms-track-get track 'play-count) 0)))
      (format "%3d │ %-20s %-17s │ %-14s │ %-30s"
              play-count
              (prettyfy-string title 19)
              (prettyfy-string artist 16)
              (emms-last-played-format-date last-played)
              (prettyfy-string album 29))))

  (setq emms-track-description-function
        'phil/emms-info-track-description))

link-files 1 "${HOME}" \
    && link-files 2 "${HOME}" \
    && link-files 3 "${HOME}"

Will do the trick, assuming this is defined:

function link-files {
    from="${1}"; to="${2}"

    # first we need the same directory structure
    ( cd "${from}" && find . \( \( -name "..?" -or -name \*.elc \) \
        -prune -or -true \) -type d -exec mkdir -p "${to}/"\{\} \; )

    # now link the files to "to"
    ( cd "${from}" && find . -type f -exec ln -fs \
        "${from}/"\{\} "${to}/"\{\} \; )
}

To be honest, I thought it would be too slow but tested it on a few medium sized projects and it actually performs OK.

(defun insert-edited-files ()
  (interactive)
  (let ((pos (point)))
    (insert (mapconcat
             (lambda (x)
               (concat (file-name-nondirectory x) ": "))
             (log-edit-files) "\n"))
    (align-regexp pos (point) ": " 0 2)))

(with-library 'project-root
  (setq project-roots
        '(("Generic Perl Project"
           :root-contains-files ("t" "lib")
           :on-hit (lambda (p)
                     (project-root-setup-ack p)))))
  (add-hook 'cperl-mode-hook 'project-root-fetch)
  (add-hook 'dired-mode-hook 'project-root-fetch)
  (define-key dired-mode-map (kbd "r") 'project-root-goto-root))

with-library looks like this by the way:

(defmacro with-library (symbol &rest body)
  `(when (require ,symbol nil t)
     ,@body))

At the moment I only use this for anything resembling Perl projects, this being determined by the :root-contains-files property. You can also use :path-matches to pull out a path where the first match group is the root:

"\\(/home/someone/work/projects/blah\\)"

The function given to :on-hit will execute when a match for the root is found, so in my case I setup ack to cd to the root of the project first.

I'd love to get some feedback on how use(ful|less) this is to people, even in its early state.

(defun load-dir (dir)
  (mapc 'load
        (mapcar (lambda (file)
                  (if (file-exists-p (concat file "c")) (concat file "c") file))
                (directory-files dir t "\\.el$"))))

Which will load all of the files in dir favouring compiled lisp. Each of the files is named to reflect its function. Here is my lisp.d:

001-definitions.el      030-org-mode.el
002-init-load-path.el   030-sql.el
010-initial-buffers.el  040-lang-lisp.el
030-dvc.el              040-lang-perl.el
030-erc.el              060-third-party-lisp.el
030-eshell.el           070-defaults.el
030-ibuffer.el          080-environment.el
030-muse.el

Within the header.muse file which all pages use as their header is this snippet (in <lisp> brackets of course):

(mapconcat
 (lambda (x)
   (concat "<li"
           (when (string= (muse-publishing-directive "menu-name") (car x))
             " id=\"current\"")
           "><a href=\"" (cdr x) "\"><span>"
           (car x) "</span></a></li>"))
 muse/web-menu-alist "\n")

This depends on setting a directive in each page called menu-name. As the code loops through the items in muse/web-menu-alist it will print out the link, if the (car) of the alist matches menu-name it will be given the "current" css property. This is what makes the current tab appear highlighted.

This is what muse/web-menu-alist looks like:

(setq muse/web-menu-alist
      '(("home" . "/index.html")
        ("shell" . "/content/shell.html")
        ("emacs" . "/content/emacs.html")
        ("contact" . "mailto:web@shellarchive.co.uk")))

It's really that simple I'm afraid.