Added emacs prelude and config

emacs/.emacs.d/elpa/makey-20131231.630/makey-autoloads.el

@@ -0,0 +1,21 @@
+;;; makey-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
+
+;;;### (autoloads nil "makey" "makey.el" (23122 58396 899019 650000))
+;;; Generated autoloads from makey.el
+
+(autoload 'makey-initialize-key-groups "makey" "\
+Initializes KEY-GROUP and creates all the relevant interactive commands.
+
+\(fn KEY-GROUP)" nil nil)
+
+;;;***
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; End:
+;;; makey-autoloads.el ends here

emacs/.emacs.d/elpa/makey-20131231.630/makey-pkg.el

@@ -0,0 +1,2 @@
+;;; -*- no-byte-compile: t -*-
+(define-package "makey" "20131231.630" "interactive commandline mode" '((cl-lib "0.2")) :commit "a61781e69d3b451551e269446e1c5f624ab81137")

emacs/.emacs.d/elpa/makey-20131231.630/makey.el

@@ -0,0 +1,556 @@
+;;; makey.el --- interactive commandline mode
+
+;; Copyright (C) 2010-2013  The Magit Project Developers.
+;; Copyright (C) 2013 Mickey Petersen
+
+;; Author: Mickey Petersen <mickey@masteringemacs.org>
+;; Keywords:
+;; Package-Version: 20131231.630
+;; Version: 0.3
+;; Package-Requires: ((cl-lib "0.2"))
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;
+
+;;; Code:
+
+(eval-when-compile (require 'cl-lib))
+
+(defvar makey-key-mode-keymaps)
+(defvar makey-key-mode-last-buffer)
+(defvar makey-pre-key-mode-window-conf)
+
+;;; Options
+
+(defcustom makey-key-mode-show-usage t
+  "Whether to show usage information when entering a popup."
+  :group 'makey
+  :type 'boolean)
+
+;;; Faces
+
+(defface makey-key-mode-header-face
+  '((t :inherit font-lock-keyword-face))
+  "Face for key mode header lines."
+  :group 'makey-faces)
+
+(defface makey-key-mode-button-face
+  '((t :inherit font-lock-builtin-face))
+  "Face for key mode buttons."
+  :group 'makey-faces)
+
+(defface makey-key-mode-switch-face
+  '((t :inherit font-lock-warning-face))
+  "Face for key mode switches."
+  :group 'makey-faces)
+
+(defface makey-key-mode-args-face
+  '((t :inherit widget-field))
+  "Face for key mode switch arguments."
+  :group 'makey-faces)
+
+(defun makey-key-mode-delete-group (group master-group)
+  "Delete a group from MASTER-GROUP"
+  (let ((items (assoc group master-group)))
+    (when items
+      ;; reset the cache
+      (setq makey-key-mode-keymaps nil)
+      ;; delete the whole group
+      (setq master-group
+            (delq items master-group))
+      ;; unbind the defun
+      (makey-key-mode-de-generate group))
+    master-group))
+
+(defun makey-key-mode-add-group (group master-group)
+  "Add a new group to MASTER-GROUP
+If there already is a group of that name then this will
+completely remove it and put in its place an empty one of the
+same name."
+  (when (assoc group master-group)
+    (makey-key-mode-delete-group group master-group))
+  (setq master-group
+        (cons (list group (list 'actions) (list 'switches))
+              master-group)))
+
+(defun makey-key-mode-key-defined-p (for-group key)
+  "Return t if KEY is defined as any option within FOR-GROUP
+The option may be a switch, argument or action."
+  (catch 'result
+    (let ((options (makey-key-mode-options-for-group for-group)))
+      (dolist (type '(actions switches arguments))
+        (when (assoc key (if (eq type 'actions)
+                             (makey-get-actions options)
+                           (assoc type options)))
+          (throw 'result t))))))
+
+(defun makey-key-mode-update-group (for-group thing &rest args)
+  "Abstraction for setting values in `makey-key-mode-keymaps'."
+  (let* ((options (makey-key-mode-options-for-group for-group))
+         (things (assoc thing options))
+         (key (car args)))
+    (if (cdr things)
+        (if (makey-key-mode-key-defined-p for-group key)
+            (error "%s is already defined in the %s group." key for-group)
+          (setcdr (cdr things) (cons args (cddr things))))
+      (setcdr things (list args)))
+    (setq makey-key-mode-keymaps nil)
+    things))
+
+(defun makey-key-mode-insert-argument (for-group key desc arg read-func)
+  "Add a new binding KEY in FOR-GROUP which will use READ-FUNC
+to receive input to apply to argument ARG is run.  DESC should
+be a brief description of the binding."
+  (makey-key-mode-update-group for-group 'arguments key desc arg read-func))
+
+(defun makey-key-mode-insert-switch (for-group key desc switch)
+  "Add a new binding KEY in FOR-GROUP which will add SWITCH to the
+command line when it runs.  DESC should be a brief description of
+the binding."
+  (makey-key-mode-update-group for-group 'switches key desc switch))
+
+(defun makey-key-mode-insert-action (for-group key desc func)
+  "Add a new binding KEY in FOR-GROUP which will run command FUNC.
+DESC should be a brief description of the binding."
+  (makey-key-mode-update-group for-group 'actions key desc func))
+
+(defun makey-key-mode-options-for-group (for-group)
+  "Retrieve the options for the group FOR-GROUP.
+This includes switches, commands and arguments."
+  (funcall (intern (concat "makey-key-mode-options-for-" (symbol-name for-group)))))
+
+(defun makey-key-mode-help (for-group)
+  "Provide help for a key within FOR-GROUP
+The user is prompted for the key."
+  (let* ((opts (makey-key-mode-options-for-group for-group))
+         (man-page (cadr (assoc 'man-page opts)))
+         (seq (read-key-sequence
+               (format "Enter command prefix%s: "
+                       (if man-page
+                           (format ", `?' for man `%s'" man-page)
+                         ""))))
+         (actions (makey-get-actions
+                   (makey-key-mode-options-for-group for-group))))
+    (cond
+     ;; if it is an action popup the help for the to-be-run function
+     ((assoc seq actions) (describe-function (nth 2 (assoc seq actions))))
+     ;; if there is "?" show a man page if there is one
+     ((equal seq "?")
+      (if man-page
+          (man man-page)
+        (error "No man page associated with `%s'" for-group)))
+     (t (error "No help associated with `%s'" seq)))))
+
+(defun makey-key-mode-exec-at-point ()
+  "Run action/args/option at point."
+  (interactive)
+  (let ((key (or (get-text-property (point) 'key-group-executor)
+                 (error "Nothing at point to do."))))
+    (call-interactively (lookup-key (current-local-map) key))))
+
+(defun makey-key-mode-jump-to-next-exec ()
+  "Jump to the next action/args/option point."
+  (interactive)
+  (let* ((oldp (point))
+         (old  (get-text-property oldp 'key-group-executor))
+         (p    (if (= oldp (point-max)) (point-min) (1+ oldp))))
+    (while (let ((new (get-text-property p 'key-group-executor)))
+             (and (not (= p oldp)) (or (not new) (eq new old))))
+      (setq p (if (= p (point-max)) (point-min) (1+ p))))
+    (goto-char p)
+    (skip-chars-forward " ")))
+
+;;; Keymaps
+
+(defvar makey-key-mode-keymaps nil
+  "This will be filled lazily with proper keymaps.
+These keymaps are created using `define-key' as they're requested.")
+
+(defun makey-key-mode-build-keymap (for-group)
+  "Construct a normal looking keymap for the key mode to use.
+Put it in `makey-key-mode-keymaps' for fast lookup."
+  (let* ((options (makey-key-mode-options-for-group for-group))
+         (actions (makey-get-actions options))
+         (switches (cdr (assoc 'switches options)))
+         (lisp-switches (cdr (assoc 'lisp-switches options)))
+         (arguments (cdr (assoc 'arguments options)))
+         (lisp-arguments (cdr (assoc 'lisp-arguments options)))
+         (map (make-sparse-keymap)))
+    (suppress-keymap map 'nodigits)
+    ;; ret dwim
+    ;; (define-key map (kbd "RET") 'makey-key-mode-exec-at-point)
+    ;; tab jumps to the next "button"
+    ;; (define-key map (kbd "TAB") 'makey-key-mode-jump-to-next-exec)
+
+    ;; all maps should `quit' with `C-g' or `q'
+    (define-key map (kbd "C-g") `(lambda ()
+                                   (interactive)
+                                   (makey-key-mode-command nil)))
+    (define-key map (kbd "q")   `(lambda ()
+                                   (interactive)
+                                   (makey-key-mode-command nil)))
+    ;; run help
+    (define-key map (kbd "?") `(lambda ()
+                                 (interactive)
+                                 (makey-key-mode-help ',for-group)))
+
+    (let ((defkey (lambda (k action)
+                    ;; (when (and (lookup-key map (car k))
+                    ;;            (not (numberp (lookup-key map (car k)))))
+                    ;;   (message "Warning: overriding binding for `%s' in %S"
+                    ;;            (car k) for-group)
+                    ;;   (ding)
+                    ;;   (sit-for 2))
+                    (define-key map (kbd (car k))
+                      `(lambda () (interactive) ,action)))))
+      (dolist (k lisp-switches)
+        (funcall defkey k `(makey-key-mode-toggle-lisp-option
+                            ',for-group
+                            ;; name on-value off-value
+                            ',(nth 2 k) ',(nth 3 k) ',(nth 4 k))))
+      (dolist (k actions)
+        (funcall defkey k `(makey-key-mode-command ',(nth 2 k))))
+      (dolist (k switches)
+        (funcall defkey k `(makey-key-mode-toggle-option ',for-group ,(nth 2 k))))
+
+      (dolist (k lisp-arguments)
+        (funcall defkey k `(makey-key-mode-add-lisp-variable
+                            ',for-group ,(nth 2 k) ',(nth 3 k))))
+      (dolist (k arguments)
+        (funcall defkey k `(makey-key-mode-add-argument
+                            ',for-group ,(nth 2 k) ',(nth 3 k)))))
+
+    (push (cons for-group map) makey-key-mode-keymaps)
+    map))
+
+;;; Toggling and Running
+
+(defvar makey-key-mode-prefix nil
+  "Prefix argument to the command that brought up the key-mode window.
+For internal use.  Used by the command that's eventually invoked.")
+
+(defvar makey-key-mode-current-args nil
+  "A hash-table of current argument set.")
+
+(defvar makey-key-mode-current-lisp-arguments nil
+  "A hash-table of current lisp variables set.
+These will get let-bound when an action is called")
+
+(defvar makey-key-mode-current-lisp-options nil
+  "Current lisp option set.")
+
+(defvar makey-key-mode-current-options nil
+  "Current option set.")
+
+(defvar makey-custom-options nil
+  "List of custom options to pass to the command line.
+Do not customize this (used in the `makey-key-mode' implementation).")
+
+(defun makey-key-mode-command (func)
+  (let ((current-prefix-arg (or current-prefix-arg makey-key-mode-prefix))
+        (makey-custom-options makey-key-mode-current-options))
+    (maphash (lambda (k v)
+               (push (concat k v) makey-custom-options))
+             makey-key-mode-current-args)
+    (let ((local-let-cells '())
+          (current-variables (copy-hash-table makey-key-mode-current-lisp-arguments))
+          (current-lisp-switches (copy-alist makey-key-mode-current-lisp-options)))
+      (set-window-configuration makey-pre-key-mode-window-conf)
+      (kill-buffer makey-key-mode-last-buffer)
+      (maphash (lambda (k v)
+                 (add-to-list 'local-let-cells
+                              (list (intern k) v)))
+               current-variables)
+      (dolist (lisp-option current-lisp-switches)
+        (add-to-list 'local-let-cells (list (car lisp-option)
+                                            (cdr lisp-option))))
+      (eval `(let* ,local-let-cells
+               (when func
+                 (if (stringp func)
+                     ;; this adds keymap-style support for
+                     ;; self-inserted strings.
+                     (call-interactively 'self-insert-command nil [func])
+                   (call-interactively func))))))))
+
+
+(defun makey-key-mode-add-lisp-variable (for-group lisp-variable-name input-func)
+  (let ((input (funcall input-func (concat lisp-variable-name ": "))))
+    (puthash lisp-variable-name input makey-key-mode-current-lisp-arguments)
+    (makey-key-mode-redraw for-group)))
+
+(defun makey-key-mode-add-argument (for-group arg-name input-func)
+  (let ((input (funcall input-func (concat arg-name ": "))))
+    (puthash arg-name input makey-key-mode-current-args)
+    (makey-key-mode-redraw for-group)))
+
+(defun makey-key-mode-toggle-option (for-group option-name)
+  "Toggles the appearance of OPTION-NAME in `makey-key-mode-current-options'."
+  (if (member option-name makey-key-mode-current-options)
+      (setq makey-key-mode-current-options
+            (delete option-name makey-key-mode-current-options))
+    (add-to-list 'makey-key-mode-current-options option-name))
+  (makey-key-mode-redraw for-group))
+
+
+(defun makey-key-mode-toggle-lisp-option (for-group option-name option-value-on option-value-off)
+  "Toggles the appearance of OPTION-NAME in `makey-key-mode-current-lisp-options'.
+
+Toggles between OPTION-VALUE-ON and OPTION-VALUE-OFF"
+  (if (cdr (assoc option-name makey-key-mode-current-lisp-options))
+      (progn
+        (setq makey-key-mode-current-lisp-options
+              (assq-delete-all option-name makey-key-mode-current-lisp-options))
+        (add-to-list 'makey-key-mode-current-lisp-options (cons option-name option-value-off)))
+    (add-to-list 'makey-key-mode-current-lisp-options (cons option-name option-value-on)))
+  (makey-key-mode-redraw for-group))
+
+;;; Mode
+
+(defvar makey-key-mode-buf-name "*makey-key: %s*"
+  "Format string to create the name of the makey-key buffer.")
+
+(defvar makey-key-mode-last-buffer nil
+  "Store the last makey-key buffer used.")
+
+(defvar makey-pre-key-mode-window-conf nil
+  "Will hold the pre-menu configuration of makey.")
+
+(defun makey-key-mode (for-group &optional original-opts)
+  "Mode for makey key selection.
+All commands, switches and options can be toggled/actioned with
+the key combination highlighted before the description."
+  (interactive)
+  ;; save the window config to restore it as was (no need to make this
+  ;; buffer local)
+  (setq makey-pre-key-mode-window-conf
+        (current-window-configuration))
+  ;; setup the mode, draw the buffer
+  (let ((buf (get-buffer-create (format makey-key-mode-buf-name
+                                        (symbol-name for-group)))))
+    (setq makey-key-mode-last-buffer buf)
+    (split-window-vertically)
+    (other-window 1)
+    (switch-to-buffer buf)
+    (kill-all-local-variables)
+    (set (make-local-variable 'scroll-margin) 0)
+    (set (make-local-variable
+          'makey-key-mode-current-options)
+         original-opts)
+    (set (make-local-variable
+          'makey-key-mode-current-lisp-options)
+         original-opts)
+    (set (make-local-variable
+          'makey-key-mode-current-args)
+         (make-hash-table))
+    (set (make-local-variable
+          'makey-key-mode-current-lisp-arguments)
+         (make-hash-table))
+    (set (make-local-variable 'makey-key-mode-prefix) current-prefix-arg)
+    (makey-key-mode-redraw for-group))
+  (when makey-key-mode-show-usage
+    (message (concat "Type a prefix key to toggle it. "
+                     "Run 'actions' with their prefixes. "
+                     "'?' for more help."))))
+
+(defun makey-key-mode-get-key-map (for-group)
+  "Get or build the keymap for FOR-GROUP."
+  (or (cdr (assoc for-group makey-key-mode-keymaps))
+      (makey-key-mode-build-keymap for-group)))
+
+(defun makey-key-mode-redraw (for-group)
+  "(re)draw the makey key buffer."
+  (let ((buffer-read-only nil)
+        (current-exec (get-text-property (point) 'key-group-executor))
+        (new-exec-pos)
+        (old-point (point))
+        (is-first (zerop (buffer-size)))
+        (actions-p nil))
+    (erase-buffer)
+    (make-local-variable 'font-lock-defaults)
+    (use-local-map (makey-key-mode-get-key-map for-group))
+    (setq actions-p (makey-key-mode-draw for-group))
+    (delete-trailing-whitespace)
+    (setq mode-name "makey-key-mode" major-mode 'makey-key-mode)
+    (when current-exec
+      (setq new-exec-pos
+            (cdr (assoc current-exec
+                        (makey-key-mode-build-exec-point-alist)))))
+    (cond ((and is-first actions-p)
+           (goto-char actions-p)
+           (makey-key-mode-jump-to-next-exec))
+          (new-exec-pos
+           (goto-char new-exec-pos)
+           (skip-chars-forward " "))
+          (t
+           (goto-char old-point))))
+  (setq buffer-read-only t)
+  (fit-window-to-buffer))
+
+(defun makey-key-mode-build-exec-point-alist ()
+  (save-excursion
+    (goto-char (point-min))
+    (let* ((exec (get-text-property (point) 'key-group-executor))
+           (exec-alist (and exec `((,exec . ,(point))))))
+      (cl-do nil ((eobp) (nreverse exec-alist))
+        (when (not (eq exec (get-text-property (point) 'key-group-executor)))
+          (setq exec (get-text-property (point) 'key-group-executor))
+          (when exec (push (cons exec (point)) exec-alist)))
+        (forward-char)))))
+
+;;; Draw Buffer
+
+(defun makey-key-mode-draw-header (header)
+  "Draw a header with the correct face."
+  (insert (propertize header 'face 'makey-key-mode-header-face) "\n"))
+
+(defvar makey-key-mode-args-in-cols nil
+  "When true, draw arguments in columns as with switches and options.")
+
+(defun makey-key-mode-draw-args (args hash-table)
+  "Draw the args part of the menu."
+  (makey-key-mode-draw-buttons
+   "Args"
+   args
+   (lambda (x)
+     (let* ((arg (nth 2 x))
+            (value (gethash arg hash-table "")))
+       (format "(%s) %s" arg
+               (propertize (if (numberp value) (int-to-string value) value)
+                           'face 'makey-key-mode-args-face))))
+   (not makey-key-mode-args-in-cols)))
+
+(defun makey-key-mode-draw-switches (switches switch-variable)
+  "Draw the switches part of the menu."
+  (makey-key-mode-draw-buttons
+   "Switches"
+   switches
+   (lambda (x)
+     (format "(%s)" (let* ((sym (nth 2 x))
+                           (s (if (symbolp sym) (symbol-name sym) sym)))
+                      (if (cdr (assoc sym switch-variable))
+                          (propertize s 'face 'makey-key-mode-switch-face)
+                        s))))))
+
+(defun makey-key-mode-draw-actions (header actions)
+  "Draw the actions part of the menu."
+  (makey-key-mode-draw-buttons (format "%s Actions" header) actions nil))
+
+(defun makey-key-mode-draw-buttons (section xs maker
+                                            &optional one-col-each)
+  (when xs
+    (makey-key-mode-draw-header section)
+    (makey-key-mode-draw-in-cols
+     (mapcar (lambda (x)
+               (let* ((head (propertize (car x) 'face 'makey-key-mode-button-face))
+                      (desc (nth 1 x))
+                      (more (and maker (funcall maker x)))
+                      (text (format " %s: %s%s%s"
+                                    head desc (if more " " "") (or more ""))))
+                 (propertize text 'key-group-executor (car x))))
+             xs)
+     one-col-each)))
+
+(defun makey-key-mode-draw-in-cols (strings one-col-each)
+  "Given a list of strings, print in columns (using `insert').
+If ONE-COL-EACH is true then don't columify, but rather, draw
+each item on one line."
+  (let ((longest-act (apply 'max (mapcar 'length strings))))
+    (while strings
+      (let ((str (car strings)))
+        (let ((padding (make-string (- (+ longest-act 3) (length str)) ? )))
+          (insert str)
+          (if (or one-col-each
+                  (and (> (+ (length padding) ;
+                             (current-column)
+                             longest-act)
+                          (window-width))
+                       (cdr strings)))
+              (insert "\n")
+            (insert padding))))
+      (setq strings (cdr strings))))
+  (insert "\n"))
+
+(defun makey-get-actions (for-group)
+  "Returns a list of actions in FOR-GROUP"
+  (cl-loop
+   for sub-group in (cdr (assoc 'actions for-group))
+   append (cdr sub-group) into action-items finally return action-items))
+
+(defun makey-key-mode-draw (for-group)
+  "Draw actions, switches and parameters.
+Return the point before the actions part, if any, nil otherwise."
+  (let* ((options (makey-key-mode-options-for-group for-group))
+         (switches (cdr (assoc 'switches options)))
+         (lisp-switches (cdr (assoc 'lisp-switches options)))
+         (arguments (cdr (assoc 'arguments options)))
+         (lisp-arguments (cdr (assoc 'lisp-arguments options)))
+         (description (cdr (assoc 'description options)))
+         (actions (cdr (assoc 'actions options)))
+         (p nil))
+    (makey-key-mode-draw-switches switches makey-key-mode-current-options)
+    (makey-key-mode-draw-switches lisp-switches makey-key-mode-current-lisp-options)
+
+    (makey-key-mode-draw-args arguments makey-key-mode-current-args)
+    (makey-key-mode-draw-args lisp-arguments makey-key-mode-current-lisp-arguments)
+    (when actions (setq p (point-marker)))
+    (dolist (action actions)
+      (makey-key-mode-draw-actions (car action) (cdr action)))
+    (setq header-line-format description)
+    (insert "\n")
+    p))
+
+;;; Generate Groups
+
+(defun makey-key-mode-de-generate (group)
+  "Unbind the function for GROUP."
+  (fmakunbound
+   (intern (concat "makey-key-mode-popup-" (symbol-name group)))))
+
+(defun makey-key-mode-generate (group-name group-details)
+  "Generate the key-group-name menu for GROUP."
+  (let* ((opts group-details)
+        (lisp-variable-alist))
+    (list (dolist (switch (cdr (assoc 'lisp-switches group-details)))
+            (add-to-list 'lisp-variable-alist
+                         (cons (nth 2 switch) (symbol-value (nth 2 switch))))))
+    (eval
+     `(defun ,(intern (concat "makey-key-mode-options-for-" (symbol-name group-name))) nil
+        ,(concat "Options menu helper function for " (symbol-name group-name))
+        ',group-details))
+    (eval
+     `(defun ,(intern (concat "makey-key-mode-popup-" (symbol-name group-name))) nil
+        ,(concat "Key menu for " (symbol-name group-name))
+        (interactive)
+        (makey-key-mode
+         (quote ,group-name)
+         ',lisp-variable-alist)))))
+
+;;;###autoload
+(defun makey-initialize-key-groups (key-group)
+  "Initializes KEY-GROUP and creates all the relevant interactive commands."
+  (setq makey-key-mode-keymaps nil)
+  (mapc (lambda (g)
+          (makey-key-mode-generate (car g) (cdr g)))
+        key-group))
+
+;;;;###autoload (mapc (lambda (g) (eval `(autoload ',(intern (concat "makey-key-mode-popup-" (symbol-name (car g)))) "makey-key-mode" ,(concat "Key menu for " (symbol-name (car g))) t))) makey-key-mode-groups)
+
+(provide 'makey)
+;; Local Variables:
+;; indent-tabs-mode: nil
+;; End:
+;;; makey.el ends here