swank-clojure.el

;;; swank-clojure.el --- slime adapter for clojure
;;
;; Copyright (C) 2008-2010 Jeffrey Chu and Phil Hagelberg
;;
;; Authors: Jeffrey Chu <jochu0@gmail.com>
;;          Phil Hagelberg <technomancy@gmail.com>
;;
;; URL: http://github.com/technomancy/swank-clojure
;; Version: 1.1.0
;; Keywords: languages, lisp
;; Package-Requires: ((slime-repl "20091016") (clojure-mode "1.6"))
;;
;; This file is licensed under the terms of the GNU General Public
;; License as distributed with Emacs (press C-h C-c to view it).
;;
;;; Commentary:
;;
;; NOTE: swank-clojure.el is currently unmaintained. Please see the
;; swank-clojure readme for examples of how to start a swank server
;; from your build tool and connect to it via SLIME.
;;
;; The purpose of this file is to set up `slime-lisp-implementations'
;; to allow SLIME to communicate with the Swank server implemented in
;; Clojure. There are four ways to launch a session:
;;
;; 1. Standalone: If you just hit M-x slime, swank-clojure will
;;    download the jars for Clojure, contrib, and swank-clojure,
;;    launch an instance, and connect to it. If you just want to try
;;    out Clojure, this is all you need. Just get Swank Clojure
;;    through package.el (http://tromey.com/elpa) and stop reading here.
;;
;; 2. Custom classpath: If you want to hack on Clojure or Contrib, set
;;    swank-clojure-classpath to a list of paths to the jars you want to
;;    use and then hit M-x slime.
;;
;; 3. Project: Put your project's dependencies (either manually or using
;;    Leiningen or Maven) in the directory named by
;;    `swank-clojure-project-dep-path' (lib/ by default), then launch M-x
;;    swank-clojure-project. Note that the directory must contain
;;    swank-clojure.jar, it will not automatically be added to the
;;    classpath as it was in past versions that had to run from a checkout.
;;
;; 4. Standalone Server: Users of leiningen or clojure-maven-plugin
;;    can launch a server from a shell
;;    (http://wiki.github.com/technomancy/leiningen/emacs-integration)
;;    and connect to it from within Emacs using M-x slime-connect.
;;
;;; Code:
;;

(require 'slime)
(require 'clojure-mode)

(defgroup swank-clojure nil
  "SLIME/swank support for clojure"
  :prefix "swank-clojure-"
  :group 'applications)

(defcustom swank-clojure-java-path "java"
  "The location of the java executable"
  :type 'string
  :group 'swank-clojure)

(defcustom swank-clojure-jar-home "~/.swank-clojure/"
  "The directory where the jars necessary to run swank-clojure are kept."
  :type 'string
  :group 'swank-clojure)

(defun swank-clojure-default-classpath ()
  (append
   (when (and (file-directory-p "~/.clojure")
              (directory-files "~/.clojure" nil "swank-clojure.*jar$"))
     (directory-files "~/.clojure" t ".jar$"))
   (when (file-directory-p swank-clojure-jar-home)
     (directory-files swank-clojure-jar-home t ".jar$"))))

(defcustom swank-clojure-classpath
  (swank-clojure-default-classpath)
  "The classpath from which clojure will load from (passed into
java as the -cp argument). On default, it includes all jar files
within ~/.clojure/ and ~/.swank-clojure"
  :type 'list
  :group 'swank-clojure)

;; For backwards-compatibility:
(defvaralias 'swank-clojure-extra-classpaths 'swank-clojure-classpath)

(defcustom swank-clojure-library-paths nil
  "The library paths used when loading shared libraries,
used to set the java.library.path property"
  :type 'list
  :group 'swank-clojure)

(defcustom swank-clojure-extra-vm-args nil
  "Extra arguments to be passed to the Java VM when starting clojure.
For example -Xmx512m or -Dsun.java2d.noddraw=true"
  :type 'list
  :group 'swank-clojure)

(defcustom swank-clojure-binary nil
  "Used as a binary executable (instead of swank-clojure-java-path) if non-nil."
  :type 'string
  :group 'swank-clojure)

(defcustom swank-clojure-init-files nil
  "If provided, will be used to initialize the REPL environment."
  :type 'list
  :group 'swank-clojure)

(defcustom swank-clojure-compile-p nil
  "Whether to instruct swank-clojure to compile files. Set to nil
  if it's causing you problems."
  :type 'boolean
  :group 'swank-clojure)

(defcustom swank-clojure-project-dep-path "lib"
  "The directory (relative to the project root) to look for dependencies in
when using `swank-clojure-project'."
  :type 'string
  :group 'swank-clojure)

(defcustom swank-clojure-deps
  (list (concat "http://repo.technomancy.us/"
                "swank-clojure-1.1.0.jar")
        (concat "http://build.clojure.org/snapshots/org/"
                "clojure/clojure/1.1.0-master-SNAPSHOT/"
                "clojure-1.1.0-master-20091202.150145-1.jar")
        (concat "http://build.clojure.org/snapshots/org/"
                "clojure/clojure-contrib/1.1.0-master-SNAPSHOT/"
                "clojure-contrib-1.1.0-master-20091212.205045-1.jar"))
  "A list of urls of jars required to run swank-clojure. If they
don't exist in `swank-clojure-jar-home' and
`swank-clojure-classpath' is not set, the user will be prompted
to download them when invoking `slime'.

Due to a bug in url-retrieve-synchronously, they must be
downloaded in order of size (ascending), so if you customize
this, keep that in mind."
  :type 'list
  :group 'swank-clojure)

(defface swank-clojure-dim-trace-face
  '((((class color) (background dark))
     (:foreground "grey50"))
    (((class color) (background light))
     (:foreground "grey55")))
  "Face used to dim parentheses."
  :group 'slime-ui)

;;;###autoload
(defun swank-clojure-init (file encoding)
  (concat
   (when swank-clojure-compile-p
     "(require 'swank.loader)\n\n(swank.loader/init)\n\n")
   "(require 'swank.swank)\n\n"
   (when (boundp 'slime-protocol-version)
     (format "(swank.swank/ignore-protocol-version %S)\n\n"
             slime-protocol-version))
   ;; Hacked in call to get the localhost address to work around a bug
   ;; where the REPL doesn't pop up until the user presses Enter.
   "(do (.. java.net.InetAddress getLocalHost getHostAddress) nil)"
   (format "(swank.swank/start-server %S :encoding %S)\n\n"
           (expand-file-name file)
           (format "%s" (slime-coding-system-cl-name encoding)))))

(defun swank-clojure-find-package ()
  (let ((regexp "^(\\(clojure.core/\\)?\\(in-\\)?ns\\+?[ \t\n\r]+\\(#\\^{[^}]+}[ \t\n\r]+\\)?[:']?\\([^()\" \t\n]+\\>\\)"))
    (save-excursion
      (when (or (re-search-backward regexp nil t)
                (re-search-forward regexp nil t))
        (match-string-no-properties 4)))))

;;;###autoload
(defun swank-clojure-slime-mode-hook ()
  (slime-mode 1)
  (set (make-local-variable 'slime-find-buffer-package-function)
       'swank-clojure-find-package))

(defun swank-clojure-update-indentation (sym indent)
  (put sym 'clojure-indent-function indent))

(defun swank-clojure-concat-paths (paths)
  "Concatenate given list of `paths' using `path-separator'. (`expand-file-name'
will be used over paths too.)"
  (mapconcat 'identity (mapcar 'expand-file-name paths) path-separator))

(defun swank-clojure-parse-jar-name (url)
  (car (last (split-string url "/"))))

(defun swank-clojure-download-jar (url)
  (let ((jar-name (swank-clojure-parse-jar-name url)))
    (message "Downloading %s..." jar-name)
    (let ((download-buffer (url-retrieve-synchronously url)))
      (save-excursion
        (condition-case e
            (progn
              (set-buffer download-buffer)
              (re-search-forward "HTTP/[0-9]\.[0-9] 200 OK")
              (re-search-forward "^$" nil 'move)
              (delete-region (point-min) (+ 1 (point)))
              (write-file (concat swank-clojure-jar-home "/" jar-name))
              (kill-buffer nil))    
          (error
           ;; no recursive directory deletion on emacs 22 =(
           (dolist (j (directory-files swank-clojure-jar-home t "[^.]+$"))
             (delete-file j))
           (delete-directory swank-clojure-jar-home)
           (error "Failed to download Clojure jars.")))))))

(defun swank-clojure-dep-exists-p (jar-url)
  "True if the jar file in `jar-url' exists in `swank-clojure-jar-home'."
  (file-exists-p (expand-file-name (swank-clojure-parse-jar-name jar-url)
                                   swank-clojure-jar-home)))

(defun swank-clojure-check-install ()
  "Prompt to install Clojure if it's not already present."
  (when (and (not swank-clojure-classpath)
             (or (not (file-exists-p swank-clojure-jar-home))
                 (> (count-if-not 'swank-clojure-dep-exists-p swank-clojure-deps)
                    0))
             (y-or-n-p "It looks like Clojure is not installed. Install now? "))
    (make-directory swank-clojure-jar-home t)
    (dolist (j swank-clojure-deps)
      (swank-clojure-download-jar j))
    (setq swank-clojure-classpath (swank-clojure-default-classpath))))

;;;###autoload
(defun swank-clojure-cmd ()
  "Create the command to start clojure according to current settings."
  (swank-clojure-check-install)
  (if swank-clojure-binary
      (if (listp swank-clojure-binary)
          swank-clojure-binary
        (list swank-clojure-binary))
    (delete-if
     'null
     (append
      (list swank-clojure-java-path)
      swank-clojure-extra-vm-args
      (list
       (when swank-clojure-library-paths
         (concat "-Djava.library.path="
                 (swank-clojure-concat-paths swank-clojure-library-paths)))
       "-classpath"
       (swank-clojure-concat-paths swank-clojure-classpath)
       "clojure.main")
      (let ((init-opts '()))
        ;; TODO: cleanup
        (dolist (init-file swank-clojure-init-files init-opts)
          (setq init-opts (append init-opts (list "-i" init-file))))
        init-opts)
      (list "--repl")))))

(defun swank-clojure-reset-implementation ()
  "Redefines the clojure entry in `slime-lisp-implementations'."
  (aput 'slime-lisp-implementations 'clojure
        (list (swank-clojure-cmd) :init 'swank-clojure-init)))

;;;###autoload
(defadvice slime-read-interactive-args (before add-clojure)
  ;; Unfortunately we need to construct our Clojure-launching command
  ;; at slime-launch time to reflect changes in the classpath. Slime
  ;; has no mechanism to support this, so we must resort to advice.
  (require 'assoc)
  (swank-clojure-reset-implementation))

;; Change the repl to be more clojure friendly
(defun swank-clojure-slime-repl-modify-syntax ()
  (when (string-match "\\*slime-repl clojure\\*" (buffer-name))
    ;; modify syntax
    (set-syntax-table clojure-mode-syntax-table) 

    ;; set indentation function (already local)
    (setq lisp-indent-function 'clojure-indent-function)

    ;; set paredit keys
    (when (and (featurep 'paredit) paredit-mode (>= paredit-version 21))
      (define-key slime-repl-mode-map "{" 'paredit-open-curly)
      (define-key slime-repl-mode-map "}" 'paredit-close-curly))))

;; Debugger

(defun swank-clojure-dim-font-lock ()
  "Dim irrelevant lines in Clojure debugger buffers."
  (if (string-match "clojure" (buffer-name))
      (font-lock-add-keywords
       nil `((,(concat " [0-9]+: " (regexp-opt '("clojure.core"
                                                 "clojure.lang"
                                                 "swank." "java."))
                       ;; TODO: regexes ending in .* are ignored by
                       ;; font-lock; what gives?
                       "[a-zA-Z0-9\\._$]*")
              . font-lock-comment-face)) t)))

(add-hook 'sldb-mode-hook 'swank-clojure-dim-font-lock)

(defvar swank-clojure-project-hook nil
  "A hook to run when a new SLIME session starts via `swank-clojure-project'.
The `path' variable is bound to the project root when these functions run.")

(defun swank-clojure-javadoc (classname)
  "Show the javadoc for classname using clojure.contrib.repl-utils/javadoc"
  (interactive (list (read-from-minibuffer "Javadoc for: " (slime-sexp-at-point))))
  (slime-eval
   `(swank:eval-and-grab-output
     ,(concat "(try
       (require 'clojure.contrib.repl-utils)
       (@(ns-resolve 'clojure.contrib.repl-utils 'javadoc) " classname ")
       (catch Throwable t (.getMessage t)))"))))

(defun directoryp (path)
  "Return t is path is a directory or a symlink pointing to a directory."
  (let ((first-attr (car (file-attributes path))))
    (if (stringp first-attr)
      (directoryp first-attr)
      first-attr)))

;;;###autoload
(defun swank-clojure-project (path)
  "Setup classpath for a clojure project and starts a new SLIME session.
  Kills existing SLIME session, if any."
  (interactive (list
                (read-directory-name
                 "Project root: "
                 (if (functionp 'locate-dominating-file) ; Emacs 23 only
                     (locate-dominating-file default-directory "src")
                   default-directory))))
  ;; TODO: allow multiple SLIME sessions per Emacs instance
  (when (get-buffer "*inferior-lisp*") (kill-buffer "*inferior-lisp*"))

  (let ((slime-lisp-implementations (copy-list slime-lisp-implementations))
        (swank-clojure-extra-vm-args (copy-list swank-clojure-extra-vm-args))
        (swank-clojure-binary nil)
        (swank-clojure-classpath (let ((l (expand-file-name
                                           swank-clojure-project-dep-path path)))
                                   (if (file-directory-p l)
                                       (append
                                        (directory-files l t ".jar$")
                                        (remove-if-not
                                         'directoryp
                                         (directory-files l t "^[^\\.]")))))))

    (add-to-list 'swank-clojure-classpath (expand-file-name "classes/" path))
    (add-to-list 'swank-clojure-classpath (expand-file-name "src/" path))
    (add-to-list 'swank-clojure-classpath (expand-file-name "test/" path))
    (add-to-list 'swank-clojure-classpath (expand-file-name "resources/" path))

    ;; For Maven style project layouts
    (when (file-exists-p (expand-file-name "pom.xml" path))
      (dolist (d '("src/main/clojure/" "src/test/clojure/"
                   "target/test-classes/" "target/classes/" "target/dependency/"))
        (add-to-list 'swank-clojure-classpath (expand-file-name d path) t))
      (dolist (d (let ((l (expand-file-name "target/dependency/" path)))
                   (if (file-directory-p l)
                       (directory-files l t ".jar$"))))
        (add-to-list 'swank-clojure-classpath (expand-file-name d path) t))
      (add-to-list 'swank-clojure-extra-vm-args
                   (format "-Dclojure.compile.path=%s"
                           (expand-file-name "target/classes/" path))))
    (swank-clojure-reset-implementation)
    (run-hooks 'swank-clojure-project-hook)

    (save-window-excursion
      (let ((default-directory path))
        (slime 'clojure)))))

(provide 'swank-clojure)
;;; swank-clojure.el ends here