Update live packs to reflect recent dev work - see previous commits f…

…or history.

packs/live/clojure-pack/config/overtone-conf.el

@@ -1,3 +1,11 @@
+(setq slime-enable-evaluate-in-emacs t)
+
+(defun live-clj-eval-sync (formstring)
+  (slime-eval (list 'swank:eval-and-grab-output formstring)))
+
+(defun live-clj-eval (formstring)
+  (slime-eval-async (list 'swank:eval-and-grab-output formstring)))
+
 (defun live-overtone-display-log ()
   (interactive)
   (let* ((log-path (file-truename "~/.overtone/log/overtone.log")))
@@ -9,4 +17,81 @@
 
 (defun live-overtone-stop ()
   (interactive)
-  (slime-eval-async `(swank:eval-and-grab-output "(in-ns 'overtone.sc.server) (stop)")))
+  (live-clj-eval "(in-ns 'overtone.sc.server) (stop)"))
+
+(defun live-overtone-volume (vol)
+  (interactive "sVolume: ")
+  (live-clj-eval (concat "(in-ns 'overtone.studio.mixer) (volume " vol ")")))
+
+(setplist 'live-control-sym->overlay ())
+(setplist 'live-control-overlay->sym ())
+
+(defun live-add-live-control-overlay (overlay)
+  (let ((s (gentemp ":")))
+    (put 'live-control-overlay->sym overlay s)
+    (put 'live-control-sym->overlay s overlay)
+    (symbol-name s)))
+
+(defun live-slime-eval-defun-surrounding-overlay (overlay)
+  (save-excursion
+    (save-window-excursion
+      (switch-to-buffer (overlay-buffer overlay))
+      (goto-char (overlay-start overlay))
+      (let ((fn-at-point-escaped (replace-regexp-in-string "\"" "\\\""
+                                                           (slime-defun-at-point) t t)))
+        (slime-interactive-eval
+         (concat "(try (eval (read-string "
+                 "\"" fn-at-point-escaped "\" "
+                 ")) (catch Exception e (println \"Error when evaluating top-level form after control change\")))"))))))
+
+(defun live-control-overlay-modified (overlay after start end &rest
+                                              original-len)
+  (unless after
+    (delete-overlay overlay)
+    (live-clj-eval (concat "(in-ns 'overtone.studio.midi)
+                            (remove-handler (midi-mk-control-key-keyword \"emacs-live-insert-midi-control-\"" (symbol-name (get 'live-control-overlay->sym overlay)) "))"))))
+
+(defun live-insert-midi-control ()
+  (interactive)
+  (let ((m (point-marker)))
+    (unless (eq (char-before) 32)
+      (backward-word)
+      (mark-word)
+      (delete-region (region-beginning) (region-end)))
+    (insert "<WAITING FOR MIDI CONTROLLER MOVEMENT>")
+    (let ((new-overlay (make-overlay m (point))))
+      (let ((new-overlay-sym (live-add-live-control-overlay new-overlay)))
+        (overlay-put new-overlay 'face '(:background "deep pink"))
+        (overlay-put new-overlay 'evaporate t)
+        (overlay-put new-overlay 'modification-hooks
+                     '(live-control-overlay-modified))
+        (live-clj-eval (concat "(require 'overtone.core)
+                                (in-ns 'overtone.studio.midi)
+                               (def overlay-name " new-overlay-sym  ")"
+                               "
+                          (let [control-key (midi-capture-next-controller-control-key)
+                                handler-key (midi-mk-control-key-keyword \"emacs-live-insert-midi-control-\"" new-overlay-sym ")]
+                            (on-latest-event
+                              control-key
+                              (bound-fn [msg]
+                                 (let [new (:data2 msg)]
+                                   (swank.core/eval-in-emacs
+                                     (str \"(live-update-overlay-and-eval-defun "
+
+                               new-overlay-sym " \" new\")\"))))
+                              handler-key))"))))))
+
+(defun live-update-overlay-and-eval-defun (overlay-sym new-val)
+  (let ((overlay (get 'live-control-sym->overlay overlay-sym))
+        (inhibit-modification-hooks t))
+    (when overlay
+      (when (overlay-buffer overlay)
+        (save-excursion
+          (save-window-excursion
+            (switch-to-buffer (overlay-buffer overlay))
+            (goto-char (overlay-start overlay))
+            (insert " " (int-to-string new-val) " ")
+            (delete-region (point) (overlay-end overlay))
+            (condition-case ex
+                (live-slime-eval-defun-surrounding-overlay overlay)
+              ('error (message (format "Could not eval top-level form."))))))))))

packs/live/clojure-pack/config/paredit-conf.el

@@ -52,11 +52,53 @@ in the sexp, not the end of the current one."
                  t)))
     (delete-horizontal-space)))
 
+
+
+(defun live-paredit-forward-kill-sexp (&optional arg)
+  (interactive "p")
+  (cond ((or (paredit-in-comment-p)
+             (paredit-in-string-p)) (kill-word (or arg 1)))
+        (t (kill-sexp (or arg 1)))))
+
+(defun live-paredit-backward-kill-sexp (&optional arg)
+  (interactive "p")
+  (cond ((or (paredit-in-comment-p)
+             (paredit-in-string-p)) (backward-kill-word (or arg 1)))
+        (t (backward-kill-sexp (or arg 1)))))
+
+(defun live-paredit-backward-kill ()
+  (interactive)
+  (let ((m (point-marker)))
+    (paredit-backward-up)
+    (forward-char)
+    (delete-region (point) m)))
+
+(defun live-paredit-delete-horizontal-space ()
+  (interactive)
+  (just-one-space -1)
+  (paredit-backward-delete))
+
+(defun live-paredit-tidy-trailing-parens ()
+  (interactive)
+  (save-excursion
+    (while (ignore-errors (paredit-forward-up) t))
+    (backward-char)
+    (live-paredit-delete-horizontal-space)
+    (while
+        (or
+         (eq (char-before) ?\))
+         (eq (char-before) ?\})
+         (eq (char-before) ?\]))
+      (backward-char)
+      (live-paredit-delete-horizontal-space))))
+
 (defun live-paredit-reindent-defun (&optional argument)
   "Reindent the definition that the point is on. If the point is
   in a string or a comment, fill the paragraph instead, and with
   a prefix argument, justify as well. Doesn't mess about with
-  Clojure fn arglists when filling-paragraph in docstrings."
+  Clojure fn arglists when filling-paragraph in docstrings.
+
+  Also tidies up trailing parens when in a lisp form"
   (interactive "P")
   (cond ((paredit-in-comment-p) (fill-paragraph argument))
         ((paredit-in-string-p) (progn
@@ -67,19 +109,8 @@ in the sexp, not the end of the current one."
                                  (save-excursion
                                    (paredit-forward-up)
                                    (delete-char 1))))
-        (t (save-excursion
-             (end-of-defun)
-             (beginning-of-defun)
-             (indent-sexp)))))
-
-(defun live-paredit-forward-kill-sexp (&optional arg)
-  (interactive "p")
-  (cond ((or (paredit-in-comment-p)
-             (paredit-in-string-p)) (kill-word (or arg 1)))
-        (t (kill-sexp (or arg 1)))))
-
-(defun live-paredit-backward-kill-sexp (&optional arg)
-  (interactive "p")
-  (cond ((or (paredit-in-comment-p)
-             (paredit-in-string-p)) (backward-kill-word (or arg 1)))
-        (t (backward-kill-sexp (or arg 1)))))
+        (t (progn (save-excursion
+                    (end-of-defun)
+                    (beginning-of-defun)
+                    (indent-sexp))
+                  (live-paredit-tidy-trailing-parens)))))

packs/live/clojure-pack/lib/clojure-mode/clojure-mode.el

@@ -68,6 +68,8 @@
 ;;; Code:
 
 (require 'cl)
+(require 'tramp)
+(require 'inf-lisp)
 
 (defgroup clojure-mode nil
   "A mode for Clojure"
@@ -108,7 +110,6 @@ Clojure to load that file."
     (define-key map "\C-c\C-l" 'clojure-load-file)
     (define-key map "\C-c\C-r" 'lisp-eval-region)
     (define-key map "\C-c\C-z" 'clojure-display-inferior-lisp-buffer)
-    (define-key map (kbd "RET") 'reindent-then-newline-and-indent)
     (define-key map (kbd "C-c t") 'clojure-jump-to-test)
     (define-key map (kbd "C-c M-q") 'clojure-fill-docstring)
     map)
@@ -188,13 +189,14 @@ if that value is non-nil."
 
   (clojure-mode-font-lock-setup)
 
-  (run-mode-hooks 'clojure-mode-hook)
-  (run-hooks 'prog-mode-hook)
+  (add-hook 'paredit-mode-hook
+            (lambda ()
+              (when (>= paredit-version 21)
+                (define-key clojure-mode-map "{" 'paredit-open-curly)
+                (define-key clojure-mode-map "}" 'paredit-close-curly))))
 
-  ;; Enable curly braces when paredit is enabled in clojure-mode-hook
-  (when (and (featurep 'paredit) paredit-mode (>= paredit-version 21))
-    (define-key clojure-mode-map "{" 'paredit-open-curly)
-    (define-key clojure-mode-map "}" 'paredit-close-curly)))
+  (run-mode-hooks 'clojure-mode-hook)
+  (run-hooks 'prog-mode-hook))
 
 (defun clojure-display-inferior-lisp-buffer ()
   "Display a buffer bound to `inferior-lisp-buffer'."
@@ -349,7 +351,8 @@ elements of a def* forms."
                               "defalias" "defhinted" "defmacro-"
                               "defn-memo" "defnk" "defonce-"
                               "defstruct-" "defunbound" "defunbound-"
-                              "defvar" "defvar-"))
+                              "defvar" "defvar-"
+                              "definst" "defsynth" "defcgen"))
                 ;; Function declarations.
                 "\\)\\>"
                 ;; Any whitespace
@@ -558,13 +561,29 @@ elements of a def* forms."
       ("#?^\\sw+" 0 font-lock-preprocessor-face)
       ("\\<io\\!\\>" 0 font-lock-warning-face)
 
-      ;;Java interop highlighting
-      ("\\<\\.-?[a-z][a-zA-Z0-9]*\\>" 0 font-lock-preprocessor-face) ;; .foo .barBaz .qux01 .-flibble .-flibbleWobble
-      ("\\<[A-Z][a-zA-Z0-9_]*[a-zA-Z0-9/$_]+\\>" 0 font-lock-preprocessor-face) ;; Foo Bar$Baz Qux_ World_OpenUDP
-      ("\\<[a-zA-Z]+\\.[a-zA-Z0-9._]*[A-Z]+[a-zA-Z0-9/.$]*\\>" 0 font-lock-preprocessor-face) ;; Foo/Bar foo.bar.Baz foo.Bar/baz
-      ("[a-z]*[A-Z]+[a-z][a-zA-Z0-9$]*\\>" 0 font-lock-preprocessor-face) ;; fooBar
-      ("\\<[A-Z][a-zA-Z0-9$]*\\.\\>" 0 font-lock-preprocessor-face))) ;; Foo. BarBaz. Qux$Quux. Corge9.
+      ;;Interop Matching
+
+      ;; Should match:
+      ;; .foo .barBaz .qux01 .-flibble .-flibbleWobble Foo Bar$Baz Qux_ World_OpenUDP Foo/Bar foo.bar.Baz foo.Bar/baz Foo. BarBaz. Qux$Quux. Corge9. Foo/barBaz. fooBar
+
+      ;; Shouldn't match:
+      ;; FOO bar bar-baz clojure.repl/source
+
+      ;; Foo. BarBaz. Qux$Quux. Corge9. Foo/barBaz.
+      ("\\<[A-Z][a-zA-Z0-9$./]*\\.\\>" 0 font-lock-preprocessor-face)
+
+      ;; .foo .barBaz .qux01 .-flibble .-flibbleWobble
+      ("\\<\\.-?[a-z][a-zA-Z0-9]*\\>" 0 font-lock-preprocessor-face)
+
+      ;; Foo Bar$Baz Qux_ World_OpenUDP Foo/Bar
+      ("\\<[A-Z][a-zA-Z0-9/$_]*[a-z]+[a-zA-Z0-9/$_]*\\>" 0 font-lock-preprocessor-face)
+
+      ;; foo.bar.Baz foo.Bar/baz
+      ("\\<[a-z]+\\.[a-zA-Z0-9._]*[A-Z]+[a-zA-Z0-9/.$]*\\>" 0 font-lock-preprocessor-face)
 
+      ;; fooBar
+      ("[a-z]*[A-Z]+[a-z][a-zA-Z0-9$]*\\>" 0 font-lock-preprocessor-face)
+      ))
 
   "Default expressions to highlight in Clojure mode.")
 
@@ -650,11 +669,14 @@ This function also returns nil meaning don't specify the indentation."
                    (eq (char-after (elt state 1)) ?\())
               (+ (current-column) 2) ;; this is probably inside a defn
             (current-column)))
-      (let ((function (buffer-substring (point)
-                                        (progn (forward-sexp 1) (point))))
-            (open-paren (elt state 1))
-            method)
-        (setq method (get (intern-soft function) 'clojure-indent-function))
+      (let* ((function (buffer-substring (point)
+                                         (progn (forward-sexp 1) (point))))
+             (open-paren (elt state 1))
+             (method nil)
+             (function-tail (first
+                             (last
+                              (split-string (substring-no-properties function) "/")))))
+        (setq method (get (intern-soft function-tail) 'clojure-indent-function))
 
         (cond ((member (char-after open-paren) '(?\[ ?\{))
                (goto-char open-paren)
@@ -1011,7 +1033,7 @@ Localhost is assumed."
 should connect to for remote projects that are opened via tramp.
 
 The arguments are dir, hostname, and port.  The return value should be an `alist` of the form
-(:cmd \"command string\" :hostname \"hostname\" :port 1234)"
+  (:cmd \"command string\" :hostname \"hostname\" :port 1234)"
   :type 'function
   :group 'clojure-mode)
 
@@ -1132,13 +1154,13 @@ The arguments are dir, hostname, and port.  The return value should be an `alist
 
     (when (and (functionp 'slime-disconnect)
                (slime-current-connection)
-               ;; TODO: ask for permission once jack-in supports multiple connections
-               ;; (and (interactive-p) (y-or-n-p "Close old connections first? "))
-               )
-      (slime-disconnect))
-    (clojure-kill-swank-buffer swank-buffer-name)
-    (clojure-jack-in-start-process connection-name swank-buffer-name dir hostname))
-  (message "Starting swank server..."))
+               (and (called-interactively-p 'any)
+                    (y-or-n-p "Close old connections first? ")))
+      (slime-disconnect)
+      (clojure-kill-swank-buffer swank-buffer-name))
+    (clojure-jack-in-start-process connection-name swank-buffer-name
+                                   dir hostname)
+    (message "Starting swank server...")))
 
 (defun clojure-find-ns ()
   (let ((regexp clojure-namespace-name-regex))