diff --git a/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle-autoloads.el b/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle-autoloads.el new file mode 100644 index 00000000..80038f81 --- /dev/null +++ b/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle-autoloads.el @@ -0,0 +1,53 @@ +;;; yasnippet-bundle-autoloads.el --- automatically extracted autoloads +;; +;;; Code: + + +;;;### (autoloads (yas/minor-mode yas/root-directory) "yasnippet-bundle" +;;;;;; "yasnippet-bundle.el" (20808 10390)) +;;; Generated autoloads from yasnippet-bundle.el + +(defvar yas/root-directory nil "\ +Root directory that stores the snippets for each major mode. + +If you set this from your .emacs, can also be a list of strings, +for multiple root directories. If you make this a list, the first +element is always the user-created snippets directory. Other +directories are used for bulk reloading of all snippets using +`yas/reload-all'") + +(custom-autoload 'yas/root-directory "yasnippet-bundle" nil) + +(autoload 'yas/minor-mode "yasnippet-bundle" "\ +Toggle YASnippet mode. + +When YASnippet mode is enabled, the `tas/trigger-key' key expands +snippets of code depending on the mode. + +With no argument, this command toggles the mode. +positive prefix argument turns on the mode. +Negative prefix argument turns off the mode. + +You can customize the key through `yas/trigger-key'. + +Key bindings: +\\{yas/minor-mode-map} + +\(fn &optional ARG)" t nil) +(require 'yasnippet-bundle) + +;;;*** + +;;;### (autoloads nil nil ("yasnippet-bundle-pkg.el") (20808 10390 +;;;;;; 105102)) + +;;;*** + +(provide 'yasnippet-bundle-autoloads) +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; coding: utf-8 +;; End: +;;; yasnippet-bundle-autoloads.el ends here diff --git a/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle-pkg.el b/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle-pkg.el new file mode 100644 index 00000000..84bc4278 --- /dev/null +++ b/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle-pkg.el @@ -0,0 +1 @@ +(define-package "yasnippet-bundle" "0.6.1" "Yet another snippet extension (Auto compiled bundle)" (quote nil)) diff --git a/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle.el b/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle.el new file mode 100644 index 00000000..ba3dce91 --- /dev/null +++ b/elpa/yasnippet-bundle-0.6.1/yasnippet-bundle.el @@ -0,0 +1,4459 @@ +;;; yasnippet-bundle.el --- Yet another snippet extension (Auto compiled bundle) +;;; Yasnippet.el --- Yet another snippet extension for Emacs. + +;; Copyright 2008 pluskid +;; 2009 pluskid, joaotavora + +;; Authors: pluskid , joaotavora +;; Version: 0.6.1 +;; Package-version: 0.6.1 +;; X-URL: http://code.google.com/p/yasnippet/ +;; Keywords: convenience, emulation +;; URL: http://code.google.com/p/yasnippet/ +;; EmacsWiki: YaSnippetMode + +;; This file 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 2, or (at your option) +;; any later version. + +;; This file 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 GNU Emacs; see the file COPYING. If not, write to +;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +;; Boston, MA 02111-1307, USA. + +;;; Commentary: + +;; Basic steps to setup: +;; +;; 1. In your .emacs file: +;; (add-to-list 'load-path "/dir/to/yasnippet.el") +;; (require 'yasnippet) +;; 2. Place the `snippets' directory somewhere. E.g: ~/.emacs.d/snippets +;; 3. In your .emacs file +;; (setq yas/root-directory "~/.emacs/snippets") +;; (yas/load-directory yas/root-directory) +;; 4. To enable the YASnippet menu and tab-trigger expansion +;; M-x yas/minor-mode +;; 5. To globally enable the minor mode in *all* buffers +;; M-x yas/global-mode +;; +;; Steps 4. and 5. are optional, you don't have to use the minor +;; mode to use YASnippet. +;; +;; Interesting variables are: +;; +;; `yas/root-directory' +;; +;; The directory where user-created snippets are to be +;; stored. Can also be a list of directories that +;; `yas/reload-all' will use for bulk-reloading snippets. In +;; that case the first directory the default for storing new +;; snippets. +;; +;; `yas/mode-symbol' +;; +;; A local variable that you can set in a hook to override +;; snippet-lookup based on major mode. It is a a symbol (or +;; list of symbols) that correspond to subdirectories of +;; `yas/root-directory' and is used for deciding which +;; snippets to consider for the active buffer. +;; +;; Major commands are: +;; +;; M-x yas/expand +;; +;; Try to expand snippets before point. In `yas/minor-mode', +;; this is bound to `yas/trigger-key' which you can customize. +;; +;; M-x yas/load-directory +;; +;; Prompts you for a directory hierarchy of snippets to load. +;; +;; M-x yas/insert-snippet +;; +;; Prompts you for possible snippet expansion if that is +;; possible according to buffer-local and snippet-local +;; expansion conditions. With prefix argument, ignore these +;; conditions. +;; +;; M-x yas/find-snippets +;; +;; Lets you find the snippet files in the correct +;; subdirectory of `yas/root-directory', according to the +;; active major mode (if it exists) like +;; `find-file-other-window'. +;; +;; M-x yas/visit-snippet-file +;; +;; Prompts you for possible snippet expansions like +;; `yas/insert-snippet', but instead of expanding it, takes +;; you directly to the snippet definition's file, if it +;; exists. +;; +;; M-x yas/new-snippet +;; +;; Lets you create a new snippet file in the correct +;; subdirectory of `yas/root-directory', according to the +;; active major mode. +;; +;; M-x yas/load-snippet-buffer +;; +;; When editing a snippet, this loads the snippet. This is +;; bound to "C-c C-c" while in the `snippet-mode' editing +;; mode. +;; +;; M-x yas/tryout-snippet +;; +;; When editing a snippet, this opens a new empty buffer, +;; sets it to the appropriate major mode and inserts the +;; snippet there, so you can see what it looks like. This is +;; bound to "C-c C-t" while in `snippet-mode'. +;; +;; The `dropdown-list.el' extension is bundled with YASnippet, you +;; can optionally use it the preferred "prompting method", puting in +;; your .emacs file, for example: +;; +;; (require 'dropdown-list) +;; (setq yas/prompt-functions '(yas/dropdown-prompt +;; yas/ido-prompt +;; yas/completing-prompt)) +;; +;; Also check out the customization group +;; +;; M-x customize-group RET yasnippet RET +;; +;; If you use the customization group to set variables +;; `yas/root-directory' or `yas/global-mode', make sure the path to +;; "yasnippet.el" is present in the `load-path' *before* the +;; `custom-set-variables' is executed in your .emacs file. +;; +;; For more information and detailed usage, refer to the project page: +;; http://code.google.com/p/yasnippet/ + +;;; Code: + +(require 'cl) +(require 'assoc) +(require 'easymenu) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; User customizable variables + + +(defgroup yasnippet nil + "Yet Another Snippet extension" + :group 'editing) + +;;;###autoload +(defcustom yas/root-directory nil + "Root directory that stores the snippets for each major mode. + +If you set this from your .emacs, can also be a list of strings, +for multiple root directories. If you make this a list, the first +element is always the user-created snippets directory. Other +directories are used for bulk reloading of all snippets using +`yas/reload-all'" + :type '(choice (string :tag "Single directory (string)") + (repeat :args (string) :tag "List of directories (strings)")) + :group 'yasnippet + :require 'yasnippet + :set #'(lambda (symbol new) + (let ((old (and (boundp symbol) + (symbol-value symbol)))) + (set-default symbol new) + (unless (or (not (fboundp 'yas/reload-all)) + (equal old new)) + (yas/reload-all))))) + +(defcustom yas/prompt-functions '(yas/x-prompt + yas/dropdown-prompt + yas/completing-prompt + yas/ido-prompt + yas/no-prompt) + "Functions to prompt for keys, templates, etc interactively. + +These functions are called with the following arguments: + +- PROMPT: A string to prompt the user + +- CHOICES: a list of strings or objects. + +- optional DISPLAY-FN : A function that, when applied to each of +the objects in CHOICES will return a string. + +The return value of any function you put here should be one of +the objects in CHOICES, properly formatted with DISPLAY-FN (if +that is passed). + +- To signal that your particular style of prompting is +unavailable at the moment, you can also have the function return +nil. + +- To signal that the user quit the prompting process, you can +signal `quit' with + + (signal 'quit \"user quit!\")." + :type '(repeat function) + :group 'yasnippet) + +(defcustom yas/indent-line 'auto + "Controls indenting applied to a recent snippet expansion. + +The following values are possible: + +- `fixed' Indent the snippet to the current column; + +- `auto' Indent each line of the snippet with `indent-according-to-mode' + +Every other value means don't apply any snippet-side indendation +after expansion (the manual per-line \"$>\" indentation still +applies)." + :type '(choice (const :tag "Nothing" nothing) + (const :tag "Fixed" fixed) + (const :tag "Auto" auto)) + :group 'yasnippet) + +(defcustom yas/also-auto-indent-first-line nil + "Non-nil means also auto indent first line according to mode. + +Naturally this is only valid when `yas/indent-line' is `auto'" + :type 'boolean + :group 'yasnippet) + +(defcustom yas/snippet-revival t + "Non-nil means re-activate snippet fields after undo/redo." + :type 'boolean + :group 'yasnippet) + +(defcustom yas/trigger-key "TAB" + "The key bound to `yas/expand' when function `yas/minor-mode' is active. + +Value is a string that is converted to the internal Emacs key +representation using `read-kbd-macro'." + :type 'string + :group 'yasnippet + :set #'(lambda (symbol key) + (let ((old (and (boundp symbol) + (symbol-value symbol)))) + (set-default symbol key) + ;; On very first loading of this defcustom, + ;; `yas/trigger-key' is *not* loaded. + (if (fboundp 'yas/trigger-key-reload) + (yas/trigger-key-reload old))))) + +(defcustom yas/next-field-key '("TAB" "") + "The key to navigate to next field when a snippet is active. + +Value is a string that is converted to the internal Emacs key +representation using `read-kbd-macro'. + +Can also be a list of strings." + :type '(choice (string :tag "String") + (repeat :args (string) :tag "List of strings")) + :group 'yasnippet + :set #'(lambda (symbol val) + (set-default symbol val) + (if (fboundp 'yas/init-yas-in-snippet-keymap) + (yas/init-yas-in-snippet-keymap)))) + + +(defcustom yas/prev-field-key '("" "") + "The key to navigate to previous field when a snippet is active. + +Value is a string that is converted to the internal Emacs key +representation using `read-kbd-macro'. + +Can also be a list of strings." + :type '(choice (string :tag "String") + (repeat :args (string) :tag "List of strings")) + :group 'yasnippet + :set #'(lambda (symbol val) + (set-default symbol val) + (if (fboundp 'yas/init-yas-in-snippet-keymap) + (yas/init-yas-in-snippet-keymap)))) + +(defcustom yas/skip-and-clear-key "C-d" + "The key to clear the currently active field. + +Value is a string that is converted to the internal Emacs key +representation using `read-kbd-macro'. + +Can also be a list of strings." + :type '(choice (string :tag "String") + (repeat :args (string) :tag "List of strings")) + :group 'yasnippet + :set #'(lambda (symbol val) + (set-default symbol val) + (if (fboundp 'yas/init-yas-in-snippet-keymap) + (yas/init-yas-in-snippet-keymap)))) + +(defcustom yas/triggers-in-field nil + "If non-nil, `yas/next-field-key' can trigger stacked expansions. + +Otherwise, `yas/next-field-key' just tries to move on to the next +field" + :type 'boolean + :group 'yasnippet) + +(defcustom yas/fallback-behavior 'call-other-command + "How to act when `yas/trigger-key' does *not* expand a snippet. + +- `call-other-command' means try to temporarily disable YASnippet + and call the next command bound to `yas/trigger-key'. + +- nil or the symbol `return-nil' mean do nothing. (and + `yas/expand-returns' nil) + +- A lisp form (apply COMMAND . ARGS) means interactively call + COMMAND, if ARGS is non-nil, call COMMAND non-interactively + with ARGS as arguments." + :type '(choice (const :tag "Call previous command" call-other-command) + (const :tag "Do nothing" return-nil)) + :group 'yasnippet) +(make-variable-buffer-local 'yas/fallback-behavior) + +(defcustom yas/choose-keys-first nil + "If non-nil, prompt for snippet key first, then for template. + +Otherwise prompts for all possible snippet names. + +This affects `yas/insert-snippet' and `yas/visit-snippet-file'." + :type 'boolean + :group 'yasnippet) + +(defcustom yas/choose-tables-first nil + "If non-nil, and multiple eligible snippet tables, prompts user for tables first. + +Otherwise, user chooses between the merging together of all +eligible tables. + +This affects `yas/insert-snippet', `yas/visit-snippet-file'" + :type 'boolean + :group 'yasnippet) + +(defcustom yas/use-menu 'real-modes + "Display a YASnippet menu in the menu bar. + +When non-nil, submenus for each snippet table will be listed +under the menu \"Yasnippet\". + +- If set to `real-modes' only submenus whose name more or less +corresponds to a major mode are listed. + +- If set to `abbreviate', only the current major-mode +menu and the modes set in `yas/mode-symbol' are listed. + +Any other non-nil value, every submenu is listed." + :type '(choice (const :tag "Full" t) + (const :tag "Real modes only" real-modes) + (const :tag "Abbreviate" abbreviate)) + :group 'yasnippet) + +(defcustom yas/trigger-symbol " =>" + "The text that will be used in menu to represent the trigger." + :type 'string + :group 'yasnippet) + +(defcustom yas/wrap-around-region nil + "If non-nil, snippet expansion wraps around selected region. + +The wrapping occurs just before the snippet's exit marker. This +can be overriden on a per-snippet basis." + :type 'boolean + :group 'yasnippet) + +(defcustom yas/good-grace t + "If non-nil, don't raise errors in inline elisp evaluation. + +An error string \"[yas] error\" is returned instead." + :type 'boolean + :group 'yasnippet) + +(defcustom yas/ignore-filenames-as-triggers nil + "If non-nil, don't derive tab triggers from filenames. + +This means a snippet without a \"# key:'\ directive wont have a +tab trigger." + :type 'boolean + :group 'yasnippet) + +(defcustom yas/visit-from-menu nil + "If non-nil visit snippets's files from menu, instead of expanding them. + +This cafn only work when snippets are loaded from files." + :type 'boolean + :group 'yasnippet) + +(defface yas/field-highlight-face + '((((class color) (background light)) (:background "DarkSeaGreen1")) + (t (:background "DimGrey"))) + "The face used to highlight the currently active field of a snippet" + :group 'yasnippet) + +(defface yas/field-debug-face + '() + "The face used for debugging some overlays normally hidden" + :group 'yasnippet) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; User can also customize the next defvars +(defun yas/define-some-keys (keys keymap definition) + "Bind KEYS to DEFINITION in KEYMAP, read with `read-kbd-macro'." + (let ((keys (or (and (listp keys) keys) + (list keys)))) + (dolist (key keys) + (define-key keymap (read-kbd-macro key) definition)))) + +(defvar yas/keymap + (let ((map (make-sparse-keymap))) + (mapc #'(lambda (binding) + (yas/define-some-keys (car binding) map (cdr binding))) + `((,yas/next-field-key . yas/next-field-or-maybe-expand) + (,yas/prev-field-key . yas/prev-field) + ("C-g" . yas/abort-snippet) + (,yas/skip-and-clear-key . yas/skip-and-clear-or-delete-char))) + map) + "The keymap active while a snippet expansion is in progress.") + +(defvar yas/key-syntaxes (list "w" "w_" "w_." "^ ") + "A list of syntax of a key. This list is tried in the order +to try to find a key. For example, if the list is '(\"w\" \"w_\"). +And in emacs-lisp-mode, where \"-\" has the syntax of \"_\": + +foo-bar + +will first try \"bar\", if not found, then \"foo-bar\" is tried.") + +(defvar yas/after-exit-snippet-hook + '() + "Hooks to run after a snippet exited. + +The hooks will be run in an environment where some variables bound to +proper values: + +`yas/snippet-beg' : The beginning of the region of the snippet. + +`yas/snippet-end' : Similar to beg. + +Attention: These hooks are not run when exiting nested/stackd snippet expansion!") + +(defvar yas/before-expand-snippet-hook + '() + "Hooks to run just before expanding a snippet.") + +(defvar yas/buffer-local-condition + '(if (and (not (bobp)) + (or (equal 'font-lock-comment-face + (get-char-property (1- (point)) + 'face)) + (equal 'font-lock-string-face + (get-char-property (1- (point)) + 'face)))) + '(require-snippet-condition . force-in-comment) + t) + "Snippet expanding condition. + +This variable is a lisp form: + + * If it evaluates to nil, no snippets can be expanded. + + * If it evaluates to the a cons (require-snippet-condition + . REQUIREMENT) + + * Snippets bearing no \"# condition:\" directive are not + considered + + * Snippets bearing conditions that evaluate to nil (or + produce an error) won't be onsidered. + + * If the snippet has a condition that evaluates to non-nil + RESULT: + + * If REQUIREMENT is t, the snippet is considered + + * If REQUIREMENT is `eq' RESULT, the snippet is + considered + + * Otherwise, the snippet is not considered. + + * If it evaluates to the symbol 'always, all snippets are + considered for expansion, regardless of any conditions. + + * If it evaluates to t or some other non-nil value + + * Snippet bearing no conditions, or conditions that + evaluate to non-nil, are considered for expansion. + + * Otherwise, the snippet is not considered. + +Here's an example preventing snippets from being expanded from +inside comments, in `python-mode' only, with the exception of +snippets returning the symbol 'force-in-comment in their +conditions. + + (add-hook 'python-mode-hook + '(lambda () + (setq yas/buffer-local-condition + '(if (python-in-string/comment) + '(require-snippet-condition . force-in-comment) + t)))) + +The default value is similar, it filters out potential snippet +expansions inside comments and string literals, unless the +snippet itself contains a condition that returns the symbol +`force-in-comment'.") +(make-variable-buffer-local 'yas/buffer-local-condition) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Internal variables + +(defvar yas/version "0.6.1b") + +(defvar yas/menu-table (make-hash-table) + "A hash table of MAJOR-MODE symbols to menu keymaps.") + +(defvar yas/active-keybindings nil + "A list of cons (KEYMAP . KEY) setup from defining snippets.") + +(defvar yas/known-modes + '(ruby-mode rst-mode markdown-mode) + "A list of mode which is well known but not part of emacs.") + +(defvar yas/escaped-characters + '(?\\ ?` ?' ?$ ?} ) + "List of characters which *might* need to be escaped.") + +(defconst yas/field-regexp + "${\\([0-9]+:\\)?\\([^}]*\\)}" + "A regexp to *almost* recognize a field.") + +(defconst yas/multi-dollar-lisp-expression-regexp + "$+[ \t\n]*\\(([^)]*)\\)" + "A regexp to *almost* recognize a \"$(...)\" expression.") + +(defconst yas/backquote-lisp-expression-regexp + "`\\([^`]*\\)`" + "A regexp to recognize a \"`lisp-expression`\" expression." ) + +(defconst yas/transform-mirror-regexp + "${\\(?:\\([0-9]+\\):\\)?$\\([ \t\n]*([^}]*\\)" + "A regexp to *almost* recognize a mirror with a transform.") + +(defconst yas/simple-mirror-regexp + "$\\([0-9]+\\)" + "A regexp to recognize a simple mirror.") + +(defvar yas/snippet-id-seed 0 + "Contains the next id for a snippet.") + +(defun yas/snippet-next-id () + (let ((id yas/snippet-id-seed)) + (incf yas/snippet-id-seed) + id)) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Minor mode stuff + +;; XXX: `last-buffer-undo-list' is somehow needed in Carbon Emacs for MacOSX +(defvar last-buffer-undo-list nil) + +(defvar yas/minor-mode-menu nil + "Holds the YASnippet menu") + +(defun yas/init-minor-keymap () + (let ((map (make-sparse-keymap))) + (easy-menu-define yas/minor-mode-menu + map + "Menu used when YAS/minor-mode is active." + '("YASnippet" + "----" + ["Expand trigger" yas/expand + :help "Possibly expand tab trigger before point"] + ["Insert at point..." yas/insert-snippet + :help "Prompt for an expandable snippet and expand it at point"] + ["New snippet..." yas/new-snippet + :help "Create a new snippet in an appropriate directory"] + ["Visit snippet file..." yas/visit-snippet-file + :help "Prompt for an expandable snippet and find its file"] + ["Find snippets..." yas/find-snippets + :help "Invoke `find-file' in the appropriate snippet directory"] + "----" + ("Snippet menu behaviour" + ["Visit snippets" (setq yas/visit-from-menu t) + :help "Visit snippets from the menu" + :active t :style radio :selected yas/visit-from-menu] + ["Expand snippets" (setq yas/visit-from-menu nil) + :help "Expand snippets from the menu" + :active t :style radio :selected (not yas/visit-from-menu)] + "----" + ["Show \"Real\" modes only" (setq yas/use-menu 'real-modes) + :help "Show snippet submenus for modes that appear to be real major modes" + :active t :style radio :selected (eq yas/use-menu 'real-modes)] + ["Show all modes" (setq yas/use-menu 't) + :help "Show one snippet submenu for each loaded table" + :active t :style radio :selected (eq yas/use-menu 't)] + ["Abbreviate according to current mode" (setq yas/use-menu 'abbreviate) + :help "Show only snippet submenus for the current active modes" + :active t :style radio :selected (eq yas/use-menu 'abbreviate)]) + ("Indenting" + ["Auto" (setq yas/indent-line 'auto) + :help "Indent each line of the snippet with `indent-according-to-mode'" + :active t :style radio :selected (eq yas/indent-line 'auto)] + ["Fixed" (setq yas/indent-line 'fixed) + :help "Indent the snippet to the current column" + :active t :style radio :selected (eq yas/indent-line 'fixed)] + ["None" (setq yas/indent-line 'none) + :help "Don't apply any particular snippet indentation after expansion" + :active t :style radio :selected (not (member yas/indent-line '(fixed auto)))] + "----" + ["Also auto indent first line" (setq yas/also-auto-indent-first-line + (not yas/also-auto-indent-first-line)) + :help "When auto-indenting also, auto indent the first line menu" + :active (eq yas/indent-line 'auto) + :style toggle :selected yas/also-auto-indent-first-line] + ) + ("Prompting method" + ["System X-widget" (setq yas/prompt-functions + (cons 'yas/x-prompt + (remove 'yas/x-prompt + yas/prompt-functions))) + :help "Use your windowing system's (gtk, mac, windows, etc...) default menu" + :active t :style radio :selected (eq (car yas/prompt-functions) + 'yas/x-prompt)] + ["Dropdown-list" (setq yas/prompt-functions + (cons 'yas/dropdown-prompt + (remove 'yas/dropdown-prompt + yas/prompt-functions))) + :help "Use a special dropdown list" + :active t :style radio :selected (eq (car yas/prompt-functions) + 'yas/dropdown-prompt)] + ["Ido" (setq yas/prompt-functions + (cons 'yas/ido-prompt + (remove 'yas/ido-prompt + yas/prompt-functions))) + :help "Use an ido-style minibuffer prompt" + :active t :style radio :selected (eq (car yas/prompt-functions) + 'yas/ido-prompt)] + ["Completing read" (setq yas/prompt-functions + (cons 'yas/completing-prompt + (remove 'yas/completing-prompt-prompt + yas/prompt-functions))) + :help "Use a normal minibuffer prompt" + :active t :style radio :selected (eq (car yas/prompt-functions) + 'yas/completing-prompt-prompt)] + ) + ("Misc" + ["Wrap region in exit marker" + (setq yas/wrap-around-region + (not yas/wrap-around-region)) + :help "If non-nil automatically wrap the selected text in the $0 snippet exit" + :style toggle :selected yas/wrap-around-region] + ["Allow stacked expansions " + (setq yas/triggers-in-field + (not yas/triggers-in-field)) + :help "If non-nil allow snippets to be triggered inside other snippet fields" + :style toggle :selected yas/triggers-in-field] + ["Revive snippets on undo " + (setq yas/snippet-revival + (not yas/snippet-revival)) + :help "If non-nil allow snippets to become active again after undo" + :style toggle :selected yas/snippet-revival] + ["Good grace " + (setq yas/good-grace + (not yas/good-grace)) + :help "If non-nil don't raise errors in bad embedded eslip in snippets" + :style toggle :selected yas/good-grace] + ["Ignore filenames as triggers" + (setq yas/ignore-filenames-as-triggers + (not yas/ignore-filenames-as-triggers)) + :help "If non-nil don't derive tab triggers from filenames" + :style toggle :selected yas/ignore-filenames-as-triggers] + ) + "----" + ["Load snippets..." yas/load-directory + :help "Load snippets from a specific directory"] + ["Reload everything" yas/reload-all + :help "Cleanup stuff, reload snippets, rebuild menus"] + ["About" yas/about + :help "Display some information about YASsnippet"])) + ;; Now for the stuff that has direct keybindings + ;; + (define-key map "\C-c&\C-s" 'yas/insert-snippet) + (define-key map "\C-c&\C-n" 'yas/new-snippet) + (define-key map "\C-c&\C-v" 'yas/visit-snippet-file) + (define-key map "\C-c&\C-f" 'yas/find-snippets) + map)) + +(defvar yas/minor-mode-map (yas/init-minor-keymap) + "The keymap used when `yas/minor-mode' is active.") + +(defun yas/trigger-key-reload (&optional unbind-key) + "Rebind `yas/expand' to the new value of `yas/trigger-key'. + +With optional UNBIND-KEY, try to unbind that key from +`yas/minor-mode-map'." + (when (and unbind-key + (stringp unbind-key) + (not (string= unbind-key ""))) + (define-key yas/minor-mode-map (read-kbd-macro unbind-key) nil)) + (when (and yas/trigger-key + (stringp yas/trigger-key) + (not (string= yas/trigger-key ""))) + (define-key yas/minor-mode-map (read-kbd-macro yas/trigger-key) 'yas/expand))) + +;;;###autoload +(define-minor-mode yas/minor-mode + "Toggle YASnippet mode. + +When YASnippet mode is enabled, the `tas/trigger-key' key expands +snippets of code depending on the mode. + +With no argument, this command toggles the mode. +positive prefix argument turns on the mode. +Negative prefix argument turns off the mode. + +You can customize the key through `yas/trigger-key'. + +Key bindings: +\\{yas/minor-mode-map}" + nil + ;; The indicator for the mode line. + " yas" + :group 'yasnippet + (when yas/minor-mode + (yas/trigger-key-reload) + ;; load all snippets definitions unless we still don't have a + ;; root-directory or some snippets have already been loaded. + (unless (or (null yas/root-directory) + (> (hash-table-count yas/snippet-tables) 0)) + (yas/reload-all)))) + +(defvar yas/dont-activate #'(lambda () + (and yas/root-directory + (null (yas/get-snippet-tables)))) + "If non-nil don't let `yas/minor-mode-on' active yas for this buffer. + +`yas/minor-mode-on' is usually called by `yas/global-mode' so +this effectively lets you define exceptions to the \"global\" +behaviour.") +(make-variable-buffer-local 'yas/dont-activate) + + +(defun yas/minor-mode-on () + "Turn on YASnippet minor mode. + +Do this unless `yas/dont-activate' is t or the function +`yas/get-snippet-tables' (which see), returns an empty list." + (interactive) + (unless (or (and (functionp yas/dont-activate) + (funcall yas/dont-activate)) + (and (not (functionp yas/dont-activate)) + yas/dont-activate)) + (yas/minor-mode 1))) + +(defun yas/minor-mode-off () + "Turn off YASnippet minor mode." + (interactive) + (yas/minor-mode -1)) + +(define-globalized-minor-mode yas/global-mode yas/minor-mode yas/minor-mode-on + :group 'yasnippet + :require 'yasnippet) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Major mode stuff +;; +(defvar yas/font-lock-keywords + (append '(("^#.*$" . font-lock-comment-face)) + lisp-font-lock-keywords + lisp-font-lock-keywords-1 + lisp-font-lock-keywords-2 + '(("$\\([0-9]+\\)" + (0 font-lock-keyword-face) + (1 font-lock-string-face t)) + ("${\\([0-9]+\\):?" + (0 font-lock-keyword-face) + (1 font-lock-warning-face t)) + ("${" font-lock-keyword-face) + ("$[0-9]+?" font-lock-preprocessor-face) + ("\\(\\$(\\)" 1 font-lock-preprocessor-face) + ("}" + (0 font-lock-keyword-face))))) + +(defun yas/init-major-keymap () + (let ((map (make-sparse-keymap))) + (easy-menu-define nil + map + "Menu used when snippet-mode is active." + (cons "Snippet" + (mapcar #'(lambda (ent) + (when (third ent) + (define-key map (third ent) (second ent))) + (vector (first ent) (second ent) t)) + (list + (list "Load this snippet" 'yas/load-snippet-buffer "\C-c\C-c") + (list "Try out this snippet" 'yas/tryout-snippet "\C-c\C-t"))))) + map)) + +(defvar snippet-mode-map + (yas/init-major-keymap) + "The keymap used when `snippet-mode' is active") + + +(define-derived-mode snippet-mode text-mode "Snippet" + "A mode for editing yasnippets" + (set-syntax-table (standard-syntax-table)) + (setq font-lock-defaults '(yas/font-lock-keywords)) + (set (make-local-variable 'require-final-newline) nil) + (use-local-map snippet-mode-map)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Internal structs for template management + +(defstruct (yas/template (:constructor yas/make-template + (content name condition expand-env file keybinding))) + "A template for a snippet." + content + name + condition + expand-env + file + keybinding) + +(defvar yas/snippet-tables (make-hash-table) + "A hash table of MAJOR-MODE symbols to `yas/snippet-table' objects.") + +(defstruct (yas/snippet-table (:constructor yas/make-snippet-table (name))) + "A table to store snippets for a particular mode. + +Has the following fields: + +`yas/snippet-table-name' + + A symbol normally corresponding to a major mode, but can also be + a pseudo major-mode to be referenced in `yas/mode-symbol', for + example. + +`yas/snippet-table-hash' + + A hash table the key is a string (the snippet key) and the + value is yet another hash of (NAME TEMPLATE), where NAME is the + snippet name and TEMPLATE is a `yas/template' object name. + +`yas/snippet-table-parents' + + A list of tables considered parents of this table: i.e. when + searching for expansions they are searched as well." + name + (hash (make-hash-table :test 'equal)) + (parents nil)) + +(defvar yas/better-guess-for-replacements nil + "If non-nil `yas/store' better guess snippet replacements.") + +(defun yas/store (table name key template) + "Store a snippet template in the TABLE." + + ;; This is dones by searching twice: + ;; + ;; * Try to get the existing namehash from TABLE using key. + ;; + ;; * Try to get the existing namehash from by searching the *whole* + ;; snippet table for NAME. This is becuase they user might have + ;; changed the key and that can no longer be used to locate the + ;; previous `yas/template-structure'. + ;; + ;; * If that returns nothing, oh well... + ;; + (dolist (existing-namehash (remove nil (list (gethash key (yas/snippet-table-hash table)) + (when yas/better-guess-for-replacements + (let (a) + (maphash #'(lambda (key namehash) + (when (gethash name namehash) + (setq a namehash))) + (yas/snippet-table-hash table)) + a))))) + (let ((existing-template (gethash name existing-namehash))) + (when existing-template + ;; Remove the existing keybinding + (when (yas/template-keybinding existing-template) + (define-key + (symbol-value (first (yas/template-keybinding existing-template))) + (second (yas/template-keybinding existing-template)) + nil) + (setq yas/active-keybindings + (delete (yas/template-keybinding existing-template) + yas/active-keybindings))) + ;; Remove the (name . template) mapping from existing-namehash. + (remhash name existing-namehash)))) + ;; Now store the new template independent of the previous steps. + ;; + (puthash name + template + (or (gethash key + (yas/snippet-table-hash table)) + (puthash key + (make-hash-table :test 'equal) + (yas/snippet-table-hash table))))) + +(defun yas/fetch (table key) + "Fetch a snippet binding to KEY from TABLE." + (let* ((keyhash (yas/snippet-table-hash table)) + (namehash (and keyhash (gethash key keyhash)))) + (when namehash + (yas/filter-templates-by-condition + (let (alist) + (maphash #'(lambda (k v) + (push (cons k v) alist)) + namehash) + alist))))) + + +;; Filtering/condition logic + +(defun yas/eval-condition (condition) + (condition-case err + (save-excursion + (save-restriction + (save-match-data + (eval condition)))) + (error (progn + (message (format "[yas] error in condition evaluation: %s" + (error-message-string err))) + nil)))) + + +(defun yas/filter-templates-by-condition (templates) + "Filter the templates using the applicable condition. + +TEMPLATES is a list of cons (NAME . TEMPLATE) where NAME is a +string and TEMPLATE is a `yas/template' structure. + +This function implements the rules described in +`yas/buffer-local-condition'. See that variables documentation." + (let ((requirement (yas/require-template-specific-condition-p))) + (if (eq requirement 'always) + templates + (remove-if-not #'(lambda (pair) + (yas/template-can-expand-p (yas/template-condition (cdr pair)) requirement)) + templates)))) + +(defun yas/require-template-specific-condition-p () + "Decides if this buffer requests/requires snippet-specific +conditions to filter out potential expansions." + (if (eq 'always yas/buffer-local-condition) + 'always + (let ((local-condition (or (and (consp yas/buffer-local-condition) + (yas/eval-condition yas/buffer-local-condition)) + yas/buffer-local-condition))) + (when local-condition + (if (eq local-condition t) + t + (and (consp local-condition) + (eq 'require-snippet-condition (car local-condition)) + (symbolp (cdr local-condition)) + (cdr local-condition))))))) + +(defun yas/template-can-expand-p (condition &optional requirement) + "Evaluates CONDITION and REQUIREMENT and returns a boolean" + (let* ((requirement (or requirement + (yas/require-template-specific-condition-p))) + (result (or (null condition) + (yas/eval-condition + (condition-case err + (read condition) + (error (progn + (message (format "[yas] error reading condition: %s" + (error-message-string err)))) + nil)))))) + (cond ((eq requirement t) + result) + (t + (eq requirement result))))) + +(defun yas/snippet-table-get-all-parents (table) + (let ((parents (yas/snippet-table-parents table))) + (when parents + (append (copy-list parents) + (mapcan #'yas/snippet-table-get-all-parents parents))))) + +(defun yas/snippet-table-templates (table) + (when table + (let ((acc (list))) + (maphash #'(lambda (key namehash) + (maphash #'(lambda (name template) + (push (cons name template) acc)) + namehash)) + (yas/snippet-table-hash table)) + (yas/filter-templates-by-condition acc)))) + +(defun yas/current-key () + "Get the key under current position. A key is used to find +the template of a snippet in the current snippet-table." + (let ((start (point)) + (end (point)) + (syntaxes yas/key-syntaxes) + syntax + done + templates) + (while (and (not done) syntaxes) + (setq syntax (car syntaxes)) + (setq syntaxes (cdr syntaxes)) + (save-excursion + (skip-syntax-backward syntax) + (setq start (point))) + (setq templates + (mapcan #'(lambda (table) + (yas/fetch table (buffer-substring-no-properties start end))) + (yas/get-snippet-tables))) + (if templates + (setq done t) + (setq start end))) + (list templates + start + end))) + + +(defun yas/snippet-table-all-keys (table) + (when table + (let ((acc)) + (maphash #'(lambda (key templates) + (when (yas/filter-templates-by-condition templates) + (push key acc))) + (yas/snippet-table-hash table)) + acc))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Internal functions + +(defun yas/real-mode? (mode) + "Try to find out if MODE is a real mode. The MODE bound to +a function (like `c-mode') is considered real mode. Other well +known mode like `ruby-mode' which is not part of Emacs might +not bound to a function until it is loaded. So yasnippet keeps +a list of modes like this to help the judgement." + (or (fboundp mode) + (find mode yas/known-modes))) + +(defun yas/read-and-eval-string (string) + ;; TODO: This is a possible optimization point, the expression could + ;; be stored in cons format instead of string, + "Evaluate STRING and convert the result to string." + (let ((retval (catch 'yas/exception + (condition-case err + (save-excursion + (save-restriction + (save-match-data + (widen) + (let ((result (eval (read string)))) + (when result + (format "%s" result)))))) + (error (if yas/good-grace + "[yas] elisp error!" + (error (format "[yas] elisp error: %s" + (error-message-string err))))))))) + (when (and (consp retval) + (eq 'yas/exception (car retval))) + (error (cdr retval))) + retval)) + +(defvar yas/mode-symbol nil + "If non-nil, lookup snippets using this instead of `major-mode'.") +(make-variable-buffer-local 'yas/mode-symbol) + +(defun yas/snippet-table-get-create (mode) + "Get the snippet table corresponding to MODE. + +Optional DIRECTORY gets recorded as the default directory to +search for snippet files if the retrieved/created table didn't +already have such a property." + (let ((table (gethash mode + yas/snippet-tables))) + (unless table + (setq table (yas/make-snippet-table (symbol-name mode))) + (puthash mode table yas/snippet-tables)) + table)) + +(defun yas/get-snippet-tables (&optional mode-symbol dont-search-parents) + "Get snippet tables for current buffer. + +Return a list of 'yas/snippet-table' objects indexed by mode. + +The modes are tried in this order: optional MODE-SYMBOL, then +`yas/mode-symbol', then `major-mode' then, unless +DONT-SEARCH-PARENTS is non-nil, the guessed parent mode of either +MODE-SYMBOL or `major-mode'. + +Guessing is done by looking up the MODE-SYMBOL's +`derived-mode-parent' property, see also `derived-mode-p'." + (let ((mode-tables + (mapcar #'(lambda (mode) + (gethash mode yas/snippet-tables)) + (append (list mode-symbol) + (if (listp yas/mode-symbol) + yas/mode-symbol + (list yas/mode-symbol)) + (list major-mode + (and (not dont-search-parents) + (get (or mode-symbol major-mode) + 'derived-mode-parent)))))) + (all-tables)) + (dolist (table (remove nil mode-tables)) + (push table all-tables) + (nconc all-tables (yas/snippet-table-get-all-parents table))) + (remove-duplicates all-tables))) + +(defun yas/menu-keymap-get-create (mode) + "Get the menu keymap correspondong to MODE." + (or (gethash mode yas/menu-table) + (puthash mode (make-sparse-keymap) yas/menu-table))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Template-related and snippet loading functions + +(defun yas/parse-template (&optional file) + "Parse the template in the current buffer. + +Optional FILE is the absolute file name of the file being +parsed. + +Return a snippet-definition, i.e. a list + + (KEY TEMPLATE NAME CONDITION GROUP VARS FILE KEYBINDING) + +If the buffer contains a line of \"# --\" then the contents +above this line are ignored. Variables can be set above this +line through the syntax: + +#name : value + +Here's a list of currently recognized variables: + + * name + * contributor + * condition + * key + * group + * expand-env + +#name: #include \"...\" +# -- +#include \"$1\"" + ;; + ;; + (goto-char (point-min)) + (let* ((name (and file + (file-name-nondirectory file))) + (key (unless yas/ignore-filenames-as-triggers + (and name + (file-name-sans-extension name)))) + template + bound + condition + (group (and file + (yas/calculate-group file))) + expand-env + binding) + (if (re-search-forward "^# --\n" nil t) + (progn (setq template + (buffer-substring-no-properties (point) + (point-max))) + (setq bound (point)) + (goto-char (point-min)) + (while (re-search-forward "^# *\\([^ ]+?\\) *: *\\(.*\\)$" bound t) + (when (string= "name" (match-string-no-properties 1)) + (setq name (match-string-no-properties 2))) + (when (string= "condition" (match-string-no-properties 1)) + (setq condition (match-string-no-properties 2))) + (when (string= "group" (match-string-no-properties 1)) + (setq group (match-string-no-properties 2))) + (when (string= "expand-env" (match-string-no-properties 1)) + (setq expand-env (match-string-no-properties 2))) + (when (string= "key" (match-string-no-properties 1)) + (setq key (match-string-no-properties 2))) + (when (string= "binding" (match-string-no-properties 1)) + (setq binding (match-string-no-properties 2))))) + (setq template + (buffer-substring-no-properties (point-min) (point-max)))) + (list key template name condition group expand-env file binding))) + +(defun yas/calculate-group (file) + "Calculate the group for snippet file path FILE." + (let* ((dominating-dir (locate-dominating-file file + ".yas-make-groups")) + (extra-path (and dominating-dir + (replace-regexp-in-string (concat "^" + (expand-file-name dominating-dir)) + "" + (expand-file-name file)))) + (extra-dir (and extra-path + (file-name-directory extra-path))) + (group (and extra-dir + (replace-regexp-in-string "/" + "." + (directory-file-name extra-dir))))) + group)) + +;; (defun yas/glob-files (directory &optional recurse-p append) +;; "Returns files under DIRECTORY ignoring dirs and hidden files. + +;; If RECURSE in non-nil, do that recursively." +;; (let (ret +;; (default-directory directory)) +;; (dolist (entry (directory-files ".")) +;; (cond ((or (string-match "^\\." +;; (file-name-nondirectory entry)) +;; (string-match "~$" +;; (file-name-nondirectory entry))) +;; nil) +;; ((and recurse-p +;; (file-directory-p entry)) +;; (setq ret (nconc ret +;; (yas/glob-files (expand-file-name entry) +;; recurse-p +;; (if append +;; (concat append "/" entry) +;; entry))))) +;; ((file-directory-p entry) +;; nil) +;; (t +;; (push (if append +;; (concat append "/" entry) +;; entry) ret)))) +;; ret)) + +(defun yas/subdirs (directory &optional file?) + "Return subdirs or files of DIRECTORY according to FILE?." + (remove-if (lambda (file) + (or (string-match "^\\." + (file-name-nondirectory file)) + (string-match "~$" + (file-name-nondirectory file)) + (if file? + (file-directory-p file) + (not (file-directory-p file))))) + (directory-files directory t))) + +(defun yas/make-menu-binding (template) + `(lambda () (interactive) (yas/expand-or-visit-from-menu ,template))) + +(defun yas/expand-or-visit-from-menu (template) + (if yas/visit-from-menu + (yas/visit-snippet-file-1 template) + (let ((where (if mark-active + (cons (region-beginning) (region-end)) + (cons (point) (point))))) + (yas/expand-snippet (yas/template-content template) + (car where) + (cdr where))))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Popping up for keys and templates +;; +(defun yas/prompt-for-template (templates &optional prompt) + "Interactively choose a template from the list TEMPLATES. + +TEMPLATES is a list of `yas/template'." + (when templates + (some #'(lambda (fn) + (funcall fn (or prompt "Choose a snippet: ") + templates + #'yas/template-name)) + yas/prompt-functions))) + +(defun yas/prompt-for-keys (keys &optional prompt) + "Interactively choose a template key from the list KEYS." + (when keys + (some #'(lambda (fn) + (funcall fn (or prompt "Choose a snippet key: ") keys)) + yas/prompt-functions))) + +(defun yas/prompt-for-table (tables &optional prompt) + (when tables + (some #'(lambda (fn) + (funcall fn (or prompt "Choose a snippet table: ") + tables + #'yas/snippet-table-name)) + yas/prompt-functions))) + +(defun yas/x-prompt (prompt choices &optional display-fn) + (when (and window-system choices) + (let ((keymap (cons 'keymap + (cons + prompt + (mapcar (lambda (choice) + (list choice + 'menu-item + (if display-fn + (funcall display-fn choice) + choice) + t)) + choices))))) + (when (cdr keymap) + (car (x-popup-menu (if (fboundp 'posn-at-point) + (let ((x-y (posn-x-y (posn-at-point (point))))) + (list (list (+ (car x-y) 10) + (+ (cdr x-y) 20)) + (selected-window))) + t) + keymap)))))) + +(defun yas/ido-prompt (prompt choices &optional display-fn) + (when (and (featurep 'ido) + ido-mode) + (let* ((formatted-choices (or (and display-fn + (mapcar display-fn choices)) + choices)) + (chosen (and formatted-choices + (ido-completing-read prompt + formatted-choices + nil + 'require-match + nil + nil)))) + (when chosen + (nth (position chosen formatted-choices :test #'string=) choices))))) + +(eval-when-compile (require 'dropdown-list nil t)) +(defun yas/dropdown-prompt (prompt choices &optional display-fn) + (when (featurep 'dropdown-list) + (let* ((formatted-choices (or (and display-fn + (mapcar display-fn choices)) + choices)) + (chosen (and formatted-choices + (nth (dropdown-list formatted-choices) + choices)))) + chosen))) + +(defun yas/completing-prompt (prompt choices &optional display-fn) + (let* ((formatted-choices (or (and display-fn + (mapcar display-fn choices)) + choices)) + (chosen (and formatted-choices + (completing-read prompt + formatted-choices + nil + 'require-match + nil + nil)))) + (when chosen + (nth (position chosen formatted-choices :test #'string=) choices)))) + +(defun yas/no-prompt (prompt choices &optional display-fn) + (first choices)) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Loading snippets from files +;; +(defun yas/load-directory-1 (directory &optional parents no-hierarchy-parents making-groups-sym) + "Recursively load snippet templates from DIRECTORY." + ;; TODO: Rewrite this horrible, horrible monster I created + (unless (file-exists-p (concat directory "/" ".yas-skip")) + (let* ((major-mode-and-parents (unless making-groups-sym + (yas/compute-major-mode-and-parents (concat directory "/dummy") + nil + no-hierarchy-parents))) + (yas/ignore-filenames-as-triggers (or yas/ignore-filenames-as-triggers + (file-exists-p (concat directory "/" ".yas-ignore-filenames-as-triggers")))) + (mode-sym (and major-mode-and-parents + (car major-mode-and-parents))) + (parents (if making-groups-sym + parents + (rest major-mode-and-parents))) + (snippet-defs nil) + (make-groups-p (or making-groups-sym + (file-exists-p (concat directory "/" ".yas-make-groups"))))) + (with-temp-buffer + (dolist (file (yas/subdirs directory 'no-subdirs-just-files)) + (when (file-readable-p file) + (insert-file-contents file nil nil nil t) + (push (yas/parse-template file) + snippet-defs)))) + (yas/define-snippets (or mode-sym + making-groups-sym) + snippet-defs + parents) + (dolist (subdir (yas/subdirs directory)) + (if make-groups-p + (yas/load-directory-1 subdir parents 't (or mode-sym + making-groups-sym)) + (yas/load-directory-1 subdir (list mode-sym))))))) + +(defun yas/load-directory (directory) + "Load snippet definition from a directory hierarchy. + +Below the top-level directory, each directory is a mode +name. And under each subdirectory, each file is a definition +of a snippet. The file name is the trigger key and the +content of the file is the template." + (interactive "DSelect the root directory: ") + (unless (file-directory-p directory) + (error "Error %s not a directory" directory)) + (unless yas/root-directory + (setq yas/root-directory directory)) + (dolist (dir (yas/subdirs directory)) + (yas/load-directory-1 dir nil 'no-hierarchy-parents)) + (when (interactive-p) + (message "done."))) + +(defun yas/kill-snippet-keybindings () + "Remove the all active snippet keybindings." + (interactive) + (dolist (keybinding yas/active-keybindings) + (define-key (symbol-value (first keybinding)) (second keybinding) nil)) + (setq yas/active-keybindings nil)) + +(defun yas/reload-all (&optional reset-root-directory) + "Reload all snippets and rebuild the YASnippet menu. " + (interactive "P") + ;; Turn off global modes and minor modes, save their state though + ;; + (let ((restore-global-mode (prog1 yas/global-mode + (yas/global-mode -1))) + (restore-minor-mode (prog1 yas/minor-mode + (yas/minor-mode -1)))) + ;; Empty all snippet tables and all menu tables + ;; + (setq yas/snippet-tables (make-hash-table)) + (setq yas/menu-table (make-hash-table)) + + ;; Init the `yas/minor-mode-map', taking care not to break the + ;; menu.... + ;; + (setf (cdr yas/minor-mode-map) + (cdr (yas/init-minor-keymap))) + + ;; Now, clean up the other keymaps we might have cluttered up. + (yas/kill-snippet-keybindings) + + (when reset-root-directory + (setq yas/root-directory nil)) + + ;; Reload the directories listed in `yas/root-directory' or prompt + ;; the user to select one. + ;; + (if yas/root-directory + (if (listp yas/root-directory) + (dolist (directory yas/root-directory) + (yas/load-directory directory)) + (yas/load-directory yas/root-directory)) + (call-interactively 'yas/load-directory)) + + ;; Restore the mode configuration + ;; + (when restore-minor-mode + (yas/minor-mode 1)) + (when restore-global-mode + (yas/global-mode 1)) + + (message "[yas] Reloading everything... Done."))) + +(defun yas/quote-string (string) + "Escape and quote STRING. +foo\"bar\\! -> \"foo\\\"bar\\\\!\"" + (concat "\"" + (replace-regexp-in-string "[\\\"]" + "\\\\\\&" + string + t) + "\"")) +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Yasnippet Bundle + +(defun yas/initialize () + "For backward compatibility, enable `yas/minor-mode' globally" + (yas/global-mode 1)) + +(defun yas/compile-bundle + (&optional yasnippet yasnippet-bundle snippet-roots code dropdown) + "Compile snippets in SNIPPET-ROOTS to a single bundle file. + +YASNIPPET is the yasnippet.el file path. + +YASNIPPET-BUNDLE is the output file of the compile result. + +SNIPPET-ROOTS is a list of root directories that contains the +snippets definition. + +CODE is the code to be placed at the end of the generated file +and that can initialize the YASnippet bundle. + +Last optional argument DROPDOWN is the filename of the +dropdown-list.el library. + +Here's the default value for all the parameters: + + (yas/compile-bundle \"yasnippet.el\" + \"yasnippet-bundle.el\" + \"snippets\") + \"(yas/initialize-bundle) + ### autoload + (require 'yasnippet-bundle)`\" + \"dropdown-list.el\") +" + (interactive "ffind the yasnippet.el file: \nFTarget bundle file: \nDSnippet directory to bundle: \nMExtra code? \nfdropdown-library: ") + + (let* ((yasnippet (or yasnippet + "yasnippet.el")) + (yasnippet-bundle (or yasnippet-bundle + "./yasnippet-bundle.el")) + (snippet-roots (or snippet-roots + "snippets")) + (dropdown (or dropdown + "dropdown-list.el")) + (code (or (and code + (condition-case err (read code) (error nil)) + code) + (concat "(yas/initialize-bundle)" + "\n;;;###autoload" ; break through so that won't + "(require 'yasnippet-bundle)"))) + (dirs (or (and (listp snippet-roots) snippet-roots) + (list snippet-roots))) + (bundle-buffer nil)) + (with-temp-file yasnippet-bundle + (insert ";;; yasnippet-bundle.el --- " + "Yet another snippet extension (Auto compiled bundle)\n") + (insert-file-contents yasnippet) + (goto-char (point-max)) + (insert "\n") + (when dropdown + (insert-file-contents dropdown)) + (goto-char (point-max)) + (insert ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n") + (insert ";;;; Auto-generated code ;;;;\n") + (insert ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;\n") + (insert "(defun yas/initialize-bundle ()\n" + " \"Initialize YASnippet and load snippets in the bundle.\"") + (flet ((yas/define-snippets + (mode snippets &optional parent-or-parents) + (insert ";;; snippets for " (symbol-name mode) "\n") + (let ((literal-snippets (list))) + (dolist (snippet snippets) + (let ((key (first snippet)) + (template-content (second snippet)) + (name (third snippet)) + (condition (fourth snippet)) + (group (fifth snippet)) + (expand-env (sixth snippet)) + ;; Omit the file on purpose + (file nil) ;; (seventh snippet)) + (binding (eighth snippet))) + (push `(,key + ,template-content + ,name + ,condition + ,group + ,expand-env + ,file + ,binding) + literal-snippets))) + (insert (pp-to-string `(yas/define-snippets ',mode ',literal-snippets ',parent-or-parents))) + (insert "\n\n")))) + (dolist (dir dirs) + (dolist (subdir (yas/subdirs dir)) + (yas/load-directory-1 subdir nil 'no-hierarchy-parents)))) + + (insert (pp-to-string `(yas/global-mode 1))) + (insert ")\n\n" code "\n") + + ;; bundle-specific provide and value for yas/dont-activate + (let ((bundle-feature-name (file-name-nondirectory + (file-name-sans-extension + yasnippet-bundle)))) + (insert (pp-to-string `(set-default 'yas/dont-activate + #'(lambda () + (and (or yas/root-directory + (featurep ',(make-symbol bundle-feature-name))) + (null (yas/get-snippet-tables))))))) + (insert (pp-to-string `(provide ',(make-symbol bundle-feature-name))))) + + (insert ";;; " + (file-name-nondirectory yasnippet-bundle) + " ends here\n")))) + +(defun yas/compile-textmate-bundle () + (interactive) + (yas/compile-bundle "yasnippet.el" + "./yasnippet-textmate-bundle.el" + "extras/imported/" + (concat "(yas/initialize-bundle)" + "\n;;;###autoload" ; break through so that won't + "(require 'yasnippet-textmate-bundle)") + "dropdown-list.el")) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Some user level functions +;;; + +(defun yas/about () + (interactive) + (message (concat "yasnippet (version " + yas/version + ") -- pluskid /joaotavora "))) + +(defun yas/define-snippets (mode snippets &optional parent-mode) + "Define SNIPPETS for MODE. + +SNIPPETS is a list of snippet definitions, each taking the +following form: + + (KEY TEMPLATE NAME CONDITION GROUP EXPAND-ENV FILE KEYBINDING) + +Within these, only TEMPLATE is actually mandatory. + +All the elelements are strings, including CONDITION, EXPAND-ENV +and KEYBINDING which will be `read' and eventually `eval'-ed. + +FILE is probably of very little use if you're programatically +defining snippets. + +You can use `yas/parse-template' to return such lists based on +the current buffers contents. + +Optional PARENT-MODE can be used to specify the parent tables of +MODE. It can be a mode symbol of a list of mode symbols. It does +not need to be a real mode." + (let ((snippet-table (yas/snippet-table-get-create mode)) + (parent-tables (mapcar #'yas/snippet-table-get-create + (if (listp parent-mode) + parent-mode + (list parent-mode)))) + (keymap (if yas/use-menu + (yas/menu-keymap-get-create mode) + nil))) + ;; Setup the menu + ;; + (when parent-tables + (setf (yas/snippet-table-parents snippet-table) + parent-tables) + (when yas/use-menu + (let ((parent-menu-syms-and-names + (if (listp parent-mode) + (mapcar #'(lambda (sym) + (cons sym (concat "parent mode - " (symbol-name sym)))) + parent-mode) + '((parent-mode . "parent mode"))))) + (mapc #'(lambda (sym-and-name) + (define-key keymap + (vector (intern (replace-regexp-in-string " " "_" (cdr sym-and-name)))) + (list 'menu-item (cdr sym-and-name) + (yas/menu-keymap-get-create (car sym-and-name))))) + (reverse parent-menu-syms-and-names))))) + (when yas/use-menu + (define-key yas/minor-mode-menu (vector mode) + `(menu-item ,(symbol-name mode) ,keymap + :visible (yas/show-menu-p ',mode)))) + ;; Iterate the recently parsed snippets definition + ;; + (dolist (snippet snippets) + (let* ((file (seventh snippet)) + (key (or (car snippet) + (unless yas/ignore-filenames-as-triggers + (and file + (file-name-sans-extension (file-name-nondirectory file)))))) + (name (or (third snippet) + (and file + (file-name-directory file)))) + (condition (fourth snippet)) + (group (fifth snippet)) + (keybinding (eighth snippet)) + (template nil)) + ;; Read the snippet's "binding :" expression + ;; + (condition-case err + (when keybinding + (setq keybinding (read (eighth snippet))) + (let* ((this-mode-map-symbol (intern (concat (symbol-name mode) "-map"))) + (keys (or (and (consp keybinding) + (read-kbd-macro (cdr keybinding))) + (read-kbd-macro keybinding))) + (keymap-symbol (or (and (consp keybinding) + (car keybinding)) + this-mode-map-symbol))) + (if (and (boundp keymap-symbol) + (keymapp (symbol-value keymap-symbol))) + (setq keybinding (list keymap-symbol + keys + name)) + (error (format "keymap \"%s\" does not (yet?) exist" keymap-symbol))))) + (error + (message "[yas] warning: keybinding \"%s\" invalid for snippet \"%s\" since %s." + keybinding name (error-message-string err)) + (setf keybinding nil))) + + ;; Create the `yas/template' object and store in the + ;; appropriate snippet table. This only done if we have found + ;; a key and a name for the snippet, because that is what + ;; indexes the snippet tables + ;; + (setq template (yas/make-template (second snippet) + (or name key) + condition + (sixth snippet) + (seventh snippet) + keybinding)) + (when (and key + name) + (yas/store snippet-table + name + key + template)) + ;; If we have a keybinding, register it if it does not + ;; conflict! + ;; + (when keybinding + (let ((lookup (lookup-key (symbol-value (first keybinding)) (second keybinding)))) + (if (and lookup + (not (numberp lookup))) + (message "[yas] warning: won't overwrite keybinding \"%s\" for snippet \"%s\" in `%s'" + (key-description (second keybinding)) name (first keybinding)) + (define-key + (symbol-value (first keybinding)) + (second keybinding) + `(lambda (&optional yas/prefix) + (interactive "P") + (when (yas/template-can-expand-p ,(yas/template-condition template)) + (yas/expand-snippet ,(yas/template-content template) + nil + nil + ,(yas/template-expand-env template))))) + (add-to-list 'yas/active-keybindings keybinding)))) + + ;; Setup the menu groups, reorganizing from group to group if + ;; necessary + ;; + (when yas/use-menu + (let ((group-keymap keymap)) + ;; Delete this entry from another group if already exists + ;; in some other group. An entry is considered as existing + ;; in another group if its name string-matches. + ;; + (yas/delete-from-keymap group-keymap name) + + ;; ... then add this entry to the correct group + (when (and (not (null group)) + (not (string= "" group))) + (dolist (subgroup (mapcar #'make-symbol + (split-string group "\\."))) + (let ((subgroup-keymap (lookup-key group-keymap + (vector subgroup)))) + (when (null subgroup-keymap) + (setq subgroup-keymap (make-sparse-keymap)) + (define-key group-keymap (vector subgroup) + `(menu-item ,(symbol-name subgroup) + ,subgroup-keymap))) + (setq group-keymap subgroup-keymap)))) + (define-key group-keymap (vector (gensym)) + `(menu-item ,(yas/template-name template) + ,(yas/make-menu-binding template) + :help ,name + :keys ,(when (and key name) + (concat key yas/trigger-symbol)))))))))) + +(defun yas/show-menu-p (mode) + (cond ((eq yas/use-menu 'abbreviate) + (find mode + (mapcar #'(lambda (table) + (intern (yas/snippet-table-name table))) + (yas/get-snippet-tables)))) + ((eq yas/use-menu 'real-modes) + (yas/real-mode? mode)) + (t + t))) + +(defun yas/delete-from-keymap (keymap name) + "Recursively delete items name NAME from KEYMAP and its submenus. + +Skip any submenus named \"parent mode\"" + ;; First of all, recursively enter submenus, i.e. the tree is + ;; searched depth first so that stale submenus can be found in the + ;; higher passes. + ;; + (mapc #'(lambda (item) + (when (and (keymapp (fourth item)) + (stringp (third item)) + (not (string-match "parent mode" (third item)))) + (yas/delete-from-keymap (fourth item) name))) + (rest keymap)) + ;; + (when (keymapp keymap) + (let ((pos-in-keymap)) + (while (setq pos-in-keymap + (position-if #'(lambda (item) + (and (listp item) + (or + ;; the menu item we want to delete + (and (eq 'menu-item (second item)) + (third item) + (and (string= (third item) name))) + ;; a stale subgroup + (and (keymapp (fourth item)) + (not (and (stringp (third item)) + (string-match "parent mode" + (third item)))) + (null (rest (fourth item))))))) + keymap)) + (setf (nthcdr pos-in-keymap keymap) + (nthcdr (+ 1 pos-in-keymap) keymap)))))) + +(defun yas/define (mode key template &optional name condition group) + "Define a snippet. Expanding KEY into TEMPLATE. + +NAME is a description to this template. Also update the menu if +`yas/use-menu' is `t'. CONDITION is the condition attached to +this snippet. If you attach a condition to a snippet, then it +will only be expanded when the condition evaluated to non-nil." + (yas/define-snippets mode + (list (list key template name condition group)))) + +(defun yas/hippie-try-expand (first-time?) + "Integrate with hippie expand. Just put this function in +`hippie-expand-try-functions-list'." + (if (not first-time?) + (let ((yas/fallback-behavior 'return-nil)) + (yas/expand)) + (undo 1) + nil)) + +(defun yas/expand () + "Expand a snippet before point. + +If no snippet expansion is possible, fall back to the behaviour +defined in `yas/fallback-behavior'" + (interactive) + (yas/expand-1)) + +(defun yas/expand-1 (&optional field) + "Actually fo the work for `yas/expand'" + (multiple-value-bind (templates start end) (if field + (save-restriction + (narrow-to-region (yas/field-start field) (yas/field-end field)) + (yas/current-key)) + (yas/current-key)) + (if templates + (let ((template (or (and (rest templates) ;; more than one + (yas/prompt-for-template (mapcar #'cdr templates))) + (cdar templates)))) + (when template + (yas/expand-snippet (yas/template-content template) + start + end + (yas/template-expand-env template)))) + (cond ((eq yas/fallback-behavior 'return-nil) + ;; return nil + nil) + ((eq yas/fallback-behavior 'call-other-command) + (let* ((yas/minor-mode nil) + (keys-1 (this-command-keys-vector)) + (keys-2 (and yas/trigger-key + (stringp yas/trigger-key) + (read-kbd-macro yas/trigger-key))) + (command-1 (and keys-1 (key-binding keys-1))) + (command-2 (and keys-2 (key-binding keys-2))) + (command (or (and (not (eq command-1 'yas/expand)) + command-1) + command-2))) + (when (and (commandp command) + (not (eq 'yas/expand command))) + (setq this-command command) + (call-interactively command)))) + ((and (listp yas/fallback-behavior) + (cdr yas/fallback-behavior) + (eq 'apply (car yas/fallback-behavior))) + (if (cddr yas/fallback-behavior) + (apply (cadr yas/fallback-behavior) + (cddr yas/fallback-behavior)) + (when (commandp (cadr yas/fallback-behavior)) + (setq this-command (cadr yas/fallback-behavior)) + (call-interactively (cadr yas/fallback-behavior))))) + (t + ;; also return nil if all the other fallbacks have failed + nil))))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Snippet development + +(defun yas/all-templates (tables) + "Return all snippet tables applicable for the current buffer. + +Honours `yas/choose-tables-first', `yas/choose-keys-first' and +`yas/buffer-local-condition'" + (when yas/choose-tables-first + (setq tables (list (yas/prompt-for-table tables)))) + (mapcar #'cdr + (if yas/choose-keys-first + (let ((key (yas/prompt-for-keys + (mapcan #'yas/snippet-table-all-keys tables)))) + (when key + (mapcan #'(lambda (table) + (yas/fetch table key)) + tables))) + (mapcan #'yas/snippet-table-templates tables)))) + +(defun yas/insert-snippet (&optional no-condition) + "Choose a snippet to expand, pop-up a list of choices according +to `yas/prompt-function'. + +With prefix argument NO-CONDITION, bypass filtering of snippets +by condition." + (interactive "P") + (let* ((yas/buffer-local-condition (or (and no-condition + 'always) + yas/buffer-local-condition)) + (templates (yas/all-templates (yas/get-snippet-tables))) + (template (and templates + (or (and (rest templates) ;; more than one template for same key + (yas/prompt-for-template templates)) + (car templates)))) + (where (if mark-active + (cons (region-beginning) (region-end)) + (cons (point) (point))))) + (if template + (yas/expand-snippet (yas/template-content template) + (car where) + (cdr where) + (yas/template-expand-env template)) + (message "[yas] No snippets can be inserted here!")))) + +(defun yas/visit-snippet-file () + "Choose a snippet to edit, selection like `yas/insert-snippet'. + +Only success if selected snippet was loaded from a file. Put the +visited file in `snippet-mode'." + (interactive) + (let* ((yas/buffer-local-condition 'always) + (templates (yas/all-templates (yas/get-snippet-tables))) + (template (and templates + (or (and (rest templates) ;; more than one template for same key + (yas/prompt-for-template templates + "Choose a snippet template to edit: ")) + (car templates))))) + + (when template + (yas/visit-snippet-file-1 template)))) + +(defun yas/visit-snippet-file-1 (template) + (let ((file (yas/template-file template))) + (cond ((and file (file-exists-p file)) + (find-file-other-window file) + (snippet-mode)) + (file + (message "Original file %s no longer exists!" file)) + (t + (message "This snippet was not loaded from a file!"))))) + +(defun yas/guess-snippet-directories-1 (table &optional suffix) + "Guesses possible snippet subdirsdirectories for TABLE." + (unless suffix + (setq suffix (yas/snippet-table-name table))) + (cons suffix + (mapcan #'(lambda (parent) + (yas/guess-snippet-directories-1 + parent + (concat (yas/snippet-table-name parent) "/" suffix))) + (yas/snippet-table-parents table)))) + +(defun yas/guess-snippet-directories () + "Try to guess suitable directories based on the current active +tables. + +Returns a a list of options alist TABLE -> DIRS where DIRS are +all the possibly directories where snippets of table might be +lurking." + (let ((main-dir (or (and (listp yas/root-directory) + (first yas/root-directory)) + yas/root-directory + (setq yas/root-directory "~/.emacs.d/snippets"))) + (tables (yas/get-snippet-tables))) + ;; HACK! the snippet table created here is a dummy table that + ;; holds the correct name so that `yas/make-directory-maybe' can + ;; work. The real table, if it does not exist in + ;; yas/snippet-tables will be created when the first snippet for + ;; that mode is loaded. + ;; + (unless (gethash major-mode yas/snippet-tables) + (setq tables (cons (yas/make-snippet-table (symbol-name major-mode)) + tables))) + + (mapcar #'(lambda (table) + (cons table + (mapcar #'(lambda (subdir) + (concat main-dir "/" subdir)) + (yas/guess-snippet-directories-1 table)))) + tables))) + +(defun yas/make-directory-maybe (table-and-dirs &optional main-table-string) + "Returns a dir inside TABLE-AND-DIRS, prompts for creation if none exists." + (or (some #'(lambda (dir) (when (file-directory-p dir) dir)) (cdr table-and-dirs)) + (let ((candidate (first (cdr table-and-dirs)))) + (if (y-or-n-p (format "Guessed directory (%s) for%s%s table \"%s\" does not exist! Create? " + candidate + (if (gethash (intern (yas/snippet-table-name (car table-and-dirs))) + yas/snippet-tables) + "" + " brand new") + (or main-table-string + "") + (yas/snippet-table-name (car table-and-dirs)))) + (progn + (make-directory candidate 'also-make-parents) + ;; create the .yas-parents file here... + candidate))))) + +(defun yas/new-snippet (&optional choose-instead-of-guess) + "" + (interactive "P") + (let* ((guessed-directories (yas/guess-snippet-directories)) + (option (or (and choose-instead-of-guess + (some #'(lambda (fn) + (funcall fn "Choose a snippet table: " + guessed-directories + #'(lambda (option) + (yas/snippet-table-name (car option))))) + yas/prompt-functions)) + (first guessed-directories))) + (chosen)) + (setq chosen (yas/make-directory-maybe option (unless choose-instead-of-guess + " main"))) + (unless (or chosen + choose-instead-of-guess) + (if (y-or-n-p (format "Continue guessing for other active tables %s? " + (mapcar #'(lambda (table-and-dirs) + (yas/snippet-table-name (car table-and-dirs))) + (rest guessed-directories)))) + (setq chosen (some #'yas/make-directory-maybe + (rest guessed-directories))))) + (unless (or chosen + choose-instead-of-guess) + (when (y-or-n-p "Having trouble... use snippet root dir? ") + (setq chosen (if (listp yas/root-directory) + (first yas/root-directory) + yas/root-directory)))) + (if chosen + (let ((default-directory chosen) + (name (read-from-minibuffer "Enter a snippet name: "))) + (find-file-other-window (concat name + ".yasnippet")) + (snippet-mode) + (unless (and choose-instead-of-guess + (not (y-or-n-p "Insert a snippet with useful headers? "))) + (yas/expand-snippet (format + "\ +# -*- mode: snippet -*- +# name: %s +# key: $1${2: +# binding: \"${3:keybinding}\"}${4: +# expand-env: ((${5:some-var} ${6:some-value}))} +# -- +$0" name)))) + (message "[yas] aborted snippet creation.")))) + +(defun yas/find-snippets (&optional same-window ) + "Look for user snippets in guessed current mode's directory. + +Calls `find-file' interactively in the guessed directory. + +With prefix arg SAME-WINDOW opens the buffer in the same window. + +Because snippets can be loaded from many different locations, +this has to guess the correct directory using +`yas/guess-snippet-directories', which returns a list of +options. + +If any one of these exists, it is taken and `find-file' is called +there, otherwise, proposes to create the first option returned by +`yas/guess-snippet-directories'." + (interactive "P") + (let* ((guessed-directories (yas/guess-snippet-directories)) + (chosen) + (buffer)) + (setq chosen (yas/make-directory-maybe (first guessed-directories) " main")) + (unless chosen + (if (y-or-n-p (format "Continue guessing for other active tables %s? " + (mapcar #'(lambda (table-and-dirs) + (yas/snippet-table-name (car table-and-dirs))) + (rest guessed-directories)))) + (setq chosen (some #'yas/make-directory-maybe + (rest guessed-directories))))) + (unless chosen + (when (y-or-n-p "Having trouble... go to snippet root dir? ") + (setq chosen (if (listp yas/root-directory) + (first yas/root-directory) + yas/root-directory)))) + (if chosen + (let ((default-directory chosen)) + (setq buffer (call-interactively (if same-window + 'find-file + 'find-file-other-window))) + (when buffer + (save-excursion + (set-buffer buffer) + (when (eq major-mode 'fundamental-mode) + (snippet-mode))))) + (message "Could not guess snippet dir!")))) + +(defun yas/compute-major-mode-and-parents (file &optional prompt-if-failed no-hierarchy-parents) + (let* ((file-dir (and file + (directory-file-name (or (locate-dominating-file file ".yas-make-groups") + (directory-file-name (file-name-directory file)))))) + (major-mode-name (and file-dir + (file-name-nondirectory file-dir))) + (parent-file-dir (and file-dir + (directory-file-name (file-name-directory file-dir)))) + (parent-mode-name (and parent-file-dir + (not no-hierarchy-parents) + (file-name-nondirectory parent-file-dir))) + (major-mode-sym (or (and major-mode-name + (intern major-mode-name)) + (when prompt-if-failed + (read-from-minibuffer + "[yas] Cannot auto-detect major mode! Enter a major mode: ")))) + (parent-mode-sym (and parent-mode-name + (intern parent-mode-name))) + (extra-parents-file-name (concat file-dir "/.yas-parents")) + (more-parents (when (file-readable-p extra-parents-file-name) + (mapcar #'intern + (split-string + (with-temp-buffer + (insert-file-contents extra-parents-file-name) + (buffer-substring-no-properties (point-min) + (point-max)))))))) + (when major-mode-sym + (remove nil (append (list major-mode-sym parent-mode-sym) + more-parents))))) + +(defun yas/load-snippet-buffer (&optional kill) + "Parse and load current buffer's snippet definition. + +With optional prefix argument KILL quit the window and buffer." + (interactive "P") + (if buffer-file-name + (let ((major-mode-and-parent (yas/compute-major-mode-and-parents buffer-file-name))) + (if major-mode-and-parent + (let* ((parsed (yas/parse-template buffer-file-name)) + (name (and parsed + (third parsed)))) + (when name + (let ((yas/better-guess-for-replacements t)) + (yas/define-snippets (car major-mode-and-parent) + (list parsed) + (cdr major-mode-and-parent))) + (when (and (buffer-modified-p) + (y-or-n-p "Save snippet? ")) + (save-buffer)) + (if kill + (quit-window kill) + (message "[yas] Snippet \"%s\" loaded for %s." + name + (car major-mode-and-parent))))) + (message "[yas] Cannot load snippet for unknown major mode"))) + (message "Save the buffer as a file first!"))) + +(defun yas/tryout-snippet (&optional debug) + "Test current buffers's snippet template in other buffer." + (interactive "P") + (let* ((major-mode-and-parent (yas/compute-major-mode-and-parents buffer-file-name)) + (parsed (yas/parse-template)) + (test-mode (or (and (car major-mode-and-parent) + (fboundp (car major-mode-and-parent)) + (car major-mode-and-parent)) + (intern (read-from-minibuffer "[yas] please input a mode: ")))) + (template (and parsed + (fboundp test-mode) + (yas/make-template (second parsed) + (third parsed) + nil + (sixth parsed) + nil + nil)))) + (cond (template + (let ((buffer-name (format "*YAS TEST: %s*" (yas/template-name template)))) + (set-buffer (switch-to-buffer buffer-name)) + (erase-buffer) + (setq buffer-undo-list nil) + (funcall test-mode) + (yas/expand-snippet (yas/template-content template) + (point-min) + (point-max) + (yas/template-expand-env template)) + (when debug + (add-hook 'post-command-hook 'yas/debug-snippet-vars 't 'local)))) + (t + (message "[yas] Cannot test snippet for unknown major mode"))))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; User convenience functions, for using in snippet definitions + +(defvar yas/modified-p nil + "Non-nil if field has been modified by user or transformation.") + +(defvar yas/moving-away-p nil + "Non-nil if user is about to exit field.") + +(defvar yas/text nil + "Contains current field text.") + +(defun yas/substr (str pattern &optional subexp) + "Search PATTERN in STR and return SUBEXPth match. + +If found, the content of subexp group SUBEXP (default 0) is + returned, or else the original STR will be returned." + (let ((grp (or subexp 0))) + (save-match-data + (if (string-match pattern str) + (match-string-no-properties grp str) + str)))) + +(defun yas/choose-value (possibilities) + "Prompt for a string in the list POSSIBILITIES and return it." + (unless (or yas/moving-away-p + yas/modified-p) + (some #'(lambda (fn) + (funcall fn "Choose: " possibilities)) + yas/prompt-functions))) + +(defun yas/key-to-value (alist) + "Prompt for a string in the list POSSIBILITIES and return it." + (unless (or yas/moving-away-p + yas/modified-p) + (let ((key (read-key-sequence ""))) + (when (stringp key) + (or (cdr (find key alist :key #'car :test #'string=)) + key))))) + +(defun yas/throw (text) + "Throw a yas/exception with TEXT as the reason." + (throw 'yas/exception (cons 'yas/exception text))) + +(defun yas/verify-value (possibilities) + "Verify that the current field value is in POSSIBILITIES + +Otherwise throw exception." + (when (and yas/moving-away-p (notany #'(lambda (pos) (string= pos yas/text)) possibilities)) + (yas/throw (format "[yas] field only allows %s" possibilities)))) + +(defun yas/field-value (number) + (let* ((snippet (car (yas/snippets-at-point))) + (field (and snippet + (yas/snippet-find-field snippet number)))) + (when field + (yas/field-text-for-display field)))) + +(defun yas/default-from-field (number) + (unless yas/modified-p + (yas/field-value number))) + +(defun yas/inside-string () + (equal 'font-lock-string-face (get-char-property (1- (point)) 'face))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; Snippet expansion and field management + +(defvar yas/active-field-overlay nil + "Overlays the currently active field.") + +(defvar yas/field-protection-overlays nil + "Two overlays protect the current active field ") + +(defconst yas/prefix nil + "A prefix argument for expansion direct from keybindings") + +(defvar yas/deleted-text nil + "The text deleted in the last snippet expansion.") + +(defvar yas/selected-text nil + "The selected region deleted on the last snippet expansion.") + +(defvar yas/start-column nil + "The column where the snippet expansion started.") + +(make-variable-buffer-local 'yas/active-field-overlay) +(make-variable-buffer-local 'yas/field-protection-overlays) +(make-variable-buffer-local 'yas/deleted-text) + +(defstruct (yas/snippet (:constructor yas/make-snippet ())) + "A snippet. + +..." + (fields '()) + (exit nil) + (id (yas/snippet-next-id) :read-only t) + (control-overlay nil) + active-field + ;; stacked expansion: the `previous-active-field' slot saves the + ;; active field where the child expansion took place + previous-active-field + force-exit) + +(defstruct (yas/field (:constructor yas/make-field (number start end parent-field))) + "A field." + number + start end + parent-field + (mirrors '()) + (transform nil) + (modified-p nil) + next) + +(defstruct (yas/mirror (:constructor yas/make-mirror (start end transform))) + "A mirror." + start end + (transform nil) + next) + +(defstruct (yas/exit (:constructor yas/make-exit (marker))) + marker + next) + +(defun yas/apply-transform (field-or-mirror field) + "Calculate the value of the field/mirror. If there's a transform +for this field, apply it. Otherwise, returned nil." + (let* ((yas/text (yas/field-text-for-display field)) + (text yas/text) + (yas/modified-p (yas/field-modified-p field)) + (yas/moving-away-p nil) + (transform (if (yas/mirror-p field-or-mirror) + (yas/mirror-transform field-or-mirror) + (yas/field-transform field-or-mirror))) + (start-point (if (yas/mirror-p field-or-mirror) + (yas/mirror-start field-or-mirror) + (yas/field-start field-or-mirror))) + (transformed (and transform + (save-excursion + (goto-char start-point) + (yas/read-and-eval-string transform))))) + transformed)) + +(defsubst yas/replace-all (from to &optional text) + "Replace all occurance from FROM to TO. + +With optional string TEXT do it in that string." + (if text + (replace-regexp-in-string (regexp-quote from) to text t t) + (goto-char (point-min)) + (while (search-forward from nil t) + (replace-match to t t text)))) + +(defun yas/snippet-find-field (snippet number) + (find-if #'(lambda (field) + (eq number (yas/field-number field))) + (yas/snippet-fields snippet))) + +(defun yas/snippet-sort-fields (snippet) + "Sort the fields of SNIPPET in navigation order." + (setf (yas/snippet-fields snippet) + (sort (yas/snippet-fields snippet) + '(lambda (field1 field2) + (yas/snippet-field-compare field1 field2))))) + +(defun yas/snippet-field-compare (field1 field2) + "Compare two fields. The field with a number is sorted first. +If they both have a number, compare through the number. If neither +have, compare through the field's start point" + (let ((n1 (yas/field-number field1)) + (n2 (yas/field-number field2))) + (if n1 + (if n2 + (< n1 n2) + t) + (if n2 + nil + (< (yas/field-start field1) + (yas/field-start field2)))))) + +(defun yas/field-probably-deleted-p (snippet field) + "Guess if SNIPPET's FIELD should be skipped." + (and (zerop (- (yas/field-start field) (yas/field-end field))) + (or (yas/field-parent-field field) + (and (eq field (car (last (yas/snippet-fields snippet)))) + (= (yas/field-start field) (overlay-end (yas/snippet-control-overlay snippet))))))) + +(defun yas/snippets-at-point (&optional all-snippets) + "Return a sorted list of snippets at point, most recently +inserted first." + (sort + (remove nil (remove-duplicates (mapcar #'(lambda (ov) + (overlay-get ov 'yas/snippet)) + (if all-snippets + (overlays-in (point-min) (point-max)) + (overlays-at (point)))))) + #'(lambda (s1 s2) + (<= (yas/snippet-id s2) (yas/snippet-id s1))))) + +(defun yas/next-field-or-maybe-expand () + "Try to expand a snippet at a key before point, otherwise +delegate to `yas/next-field'." + (interactive) + (if yas/triggers-in-field + (let ((yas/fallback-behavior 'return-nil) + (active-field (overlay-get yas/active-field-overlay 'yas/field))) + (when active-field + (unless (yas/expand-1 active-field) + (yas/next-field)))) + (yas/next-field))) + +(defun yas/next-field (&optional arg) + "Navigate to next field. If there's none, exit the snippet." + (interactive) + (let* ((arg (or arg + 1)) + (snippet (first (yas/snippets-at-point))) + (active-field (overlay-get yas/active-field-overlay 'yas/field)) + (live-fields (remove-if #'(lambda (field) + (and (not (eq field active-field)) + (yas/field-probably-deleted-p snippet field))) + (yas/snippet-fields snippet))) + (active-field-pos (position active-field live-fields)) + (target-pos (and active-field-pos (+ arg active-field-pos))) + (target-field (nth target-pos live-fields))) + ;; First check if we're moving out of a field with a transform + ;; + (when (and active-field + (yas/field-transform active-field)) + (let* ((yas/moving-away-p t) + (yas/text (yas/field-text-for-display active-field)) + (text yas/text) + (yas/modified-p (yas/field-modified-p active-field))) + ;; primary field transform: exit call to field-transform + (yas/read-and-eval-string (yas/field-transform active-field)))) + ;; Now actually move... + (cond ((>= target-pos (length live-fields)) + (yas/exit-snippet snippet)) + (target-field + (yas/move-to-field snippet target-field)) + (t + nil)))) + +(defun yas/place-overlays (snippet field) + "Correctly place overlays for SNIPPET's FIELD" + (yas/make-move-field-protection-overlays snippet field) + (yas/make-move-active-field-overlay snippet field)) + +(defun yas/move-to-field (snippet field) + "Update SNIPPET to move to field FIELD. + +Also create some protection overlays" + (goto-char (yas/field-start field)) + (setf (yas/snippet-active-field snippet) field) + (yas/place-overlays snippet field) + (overlay-put yas/active-field-overlay 'yas/field field) + ;; primary field transform: first call to snippet transform + (unless (yas/field-modified-p field) + (if (yas/field-update-display field snippet) + (let ((inhibit-modification-hooks t)) + (yas/update-mirrors snippet)) + (setf (yas/field-modified-p field) nil)))) + +(defun yas/prev-field () + "Navigate to prev field. If there's none, exit the snippet." + (interactive) + (yas/next-field -1)) + +(defun yas/abort-snippet (&optional snippet) + (interactive) + (let ((snippet (or snippet + (car (yas/snippets-at-point))))) + (when snippet + (setf (yas/snippet-force-exit snippet) t)))) + +(defun yas/exit-snippet (snippet) + "Goto exit-marker of SNIPPET." + (interactive) + (setf (yas/snippet-force-exit snippet) t) + (goto-char (if (yas/snippet-exit snippet) + (yas/exit-marker (yas/snippet-exit snippet)) + (overlay-end (yas/snippet-control-overlay snippet))))) + +(defun yas/exit-all-snippets () + "Exit all snippets." + (interactive) + (mapc #'(lambda (snippet) + (yas/exit-snippet snippet) + (yas/check-commit-snippet)) + (yas/snippets-at-point))) + + +;;; Apropos markers-to-points: +;;; +;;; This was found useful for performance reasons, so that an +;;; excessive number of live markers aren't kept around in the +;;; `buffer-undo-list'. However, in `markers-to-points', the +;;; set-to-nil markers can't simply be discarded and replaced with +;;; fresh ones in `points-to-markers'. The original marker that was +;;; just set to nil has to be reused. +;;; +;;; This shouldn't bring horrible problems with undo/redo, but it +;;; you never know +;;; + +(defun yas/markers-to-points (snippet) + "Convert all markers in SNIPPET to a cons (POINT . MARKER) +where POINT is the original position of the marker and MARKER is +the original marker object with the position set to nil." + (dolist (field (yas/snippet-fields snippet)) + (let ((start (marker-position (yas/field-start field))) + (end (marker-position (yas/field-end field)))) + (set-marker (yas/field-start field) nil) + (set-marker (yas/field-end field) nil) + (setf (yas/field-start field) (cons start (yas/field-start field))) + (setf (yas/field-end field) (cons end (yas/field-end field)))) + (dolist (mirror (yas/field-mirrors field)) + (let ((start (marker-position (yas/mirror-start mirror))) + (end (marker-position (yas/mirror-end mirror)))) + (set-marker (yas/mirror-start mirror) nil) + (set-marker (yas/mirror-end mirror) nil) + (setf (yas/mirror-start mirror) (cons start (yas/mirror-start mirror))) + (setf (yas/mirror-end mirror) (cons end (yas/mirror-end mirror)))))) + (let ((snippet-exit (yas/snippet-exit snippet))) + (when snippet-exit + (let ((exit (marker-position (yas/exit-marker snippet-exit)))) + (set-marker (yas/exit-marker snippet-exit) nil) + (setf (yas/exit-marker snippet-exit) (cons exit (yas/exit-marker snippet-exit))))))) + +(defun yas/points-to-markers (snippet) + "Convert all cons (POINT . MARKER) in SNIPPET to markers. This +is done by setting MARKER to POINT with `set-marker'." + (dolist (field (yas/snippet-fields snippet)) + (setf (yas/field-start field) (set-marker (cdr (yas/field-start field)) + (car (yas/field-start field)))) + (setf (yas/field-end field) (set-marker (cdr (yas/field-end field)) + (car (yas/field-end field)))) + (dolist (mirror (yas/field-mirrors field)) + (setf (yas/mirror-start mirror) (set-marker (cdr (yas/mirror-start mirror)) + (car (yas/mirror-start mirror)))) + (setf (yas/mirror-end mirror) (set-marker (cdr (yas/mirror-end mirror)) + (car (yas/mirror-end mirror)))))) + (let ((snippet-exit (yas/snippet-exit snippet))) + (when snippet-exit + (setf (yas/exit-marker snippet-exit) (set-marker (cdr (yas/exit-marker snippet-exit)) + (car (yas/exit-marker snippet-exit))))))) + +(defun yas/commit-snippet (snippet &optional no-hooks) + "Commit SNIPPET, but leave point as it is. This renders the +snippet as ordinary text. + +Return a buffer position where the point should be placed if +exiting the snippet. + +NO-HOOKS means don't run the `yas/after-exit-snippet-hook' hooks." + + (let ((control-overlay (yas/snippet-control-overlay snippet)) + yas/snippet-beg + yas/snippet-end) + ;; + ;; Save the end of the moribund snippet in case we need to revive it + ;; its original expansion. + ;; + (when (and control-overlay + (overlay-buffer control-overlay)) + (setq yas/snippet-beg (overlay-start control-overlay)) + (setq yas/snippet-end (overlay-end control-overlay)) + (delete-overlay control-overlay)) + + (let ((inhibit-modification-hooks t)) + (when yas/active-field-overlay + (delete-overlay yas/active-field-overlay)) + (when yas/field-protection-overlays + (mapc #'delete-overlay yas/field-protection-overlays))) + + ;; stacked expansion: if the original expansion took place from a + ;; field, make sure we advance it here at least to + ;; `yas/snippet-end'... + ;; + (let ((previous-field (yas/snippet-previous-active-field snippet))) + (when (and yas/snippet-end previous-field) + (yas/advance-end-maybe previous-field yas/snippet-end))) + + ;; Convert all markers to points, + ;; + (yas/markers-to-points snippet) + + ;; Take care of snippet revival + ;; + (if yas/snippet-revival + (push `(apply yas/snippet-revive ,yas/snippet-beg ,yas/snippet-end ,snippet) + buffer-undo-list) + ;; Dismember the snippet... this is useful if we get called + ;; again from `yas/take-care-of-redo'.... + (setf (yas/snippet-fields snippet) nil)) + + ;; XXX: `yas/after-exit-snippet-hook' should be run with + ;; `yas/snippet-beg' and `yas/snippet-end' bound. That might not + ;; be the case if the main overlay had somehow already + ;; disappeared, which sometimes happens when the snippet's messed + ;; up... + ;; + (unless no-hooks (run-hooks 'yas/after-exit-snippet-hook))) + + (message "[yas] snippet exited.")) + +(defun yas/check-commit-snippet () + "Checks if point exited the currently active field of the +snippet, if so cleans up the whole snippet up." + (let* ((snippets (yas/snippets-at-point 'all-snippets)) + (snippets-left snippets)) + (dolist (snippet snippets) + (let ((active-field (yas/snippet-active-field snippet))) + (cond ((or (prog1 (yas/snippet-force-exit snippet) + (setf (yas/snippet-force-exit snippet) nil)) + (not (and active-field (yas/field-contains-point-p active-field)))) + (setq snippets-left (delete snippet snippets-left)) + (yas/commit-snippet snippet snippets-left)) + ((and active-field + (or (not yas/active-field-overlay) + (not (overlay-buffer yas/active-field-overlay)))) + ;; + ;; stacked expansion: this case is mainly for recent + ;; snippet exits that place us back int the field of + ;; another snippet + ;; + (save-excursion + (yas/move-to-field snippet active-field) + (yas/update-mirrors snippet))) + (t + nil)))) + (unless snippets-left + (remove-hook 'post-command-hook 'yas/post-command-handler 'local) + (remove-hook 'pre-command-hook 'yas/pre-command-handler 'local)))) + +(defun yas/field-contains-point-p (field &optional point) + (let ((point (or point + (point)))) + (and (>= point (yas/field-start field)) + (<= point (yas/field-end field))))) + +(defun yas/field-text-for-display (field) + "Return the propertized display text for field FIELD. " + (buffer-substring (yas/field-start field) (yas/field-end field))) + +(defun yas/undo-in-progress () + "True if some kind of undo is in progress" + (or undo-in-progress + (eq this-command 'undo) + (eq this-command 'redo))) + +(defun yas/make-control-overlay (snippet start end) + "Creates the control overlay that surrounds the snippet and +holds the keymap." + (let ((overlay (make-overlay start + end + nil + nil + t))) + (overlay-put overlay 'keymap yas/keymap) + (overlay-put overlay 'yas/snippet snippet) + overlay)) + +(defun yas/skip-and-clear-or-delete-char (&optional field) + "Clears unmodified field if at field start, skips to next tab. + +Otherwise deletes a character normally by calling `delete-char'." + (interactive) + (let ((field (or field + (and yas/active-field-overlay + (overlay-buffer yas/active-field-overlay) + (overlay-get yas/active-field-overlay 'yas/field))))) + (cond ((and field + (not (yas/field-modified-p field)) + (eq (point) (marker-position (yas/field-start field)))) + (yas/skip-and-clear field) + (yas/next-field 1)) + (t + (call-interactively 'delete-char))))) + +(defun yas/skip-and-clear (field) + "Deletes the region of FIELD and sets it modified state to t" + (setf (yas/field-modified-p field) t) + (delete-region (yas/field-start field) (yas/field-end field))) + +(defun yas/make-move-active-field-overlay (snippet field) + "Place the active field overlay in SNIPPET's FIELD. + +Move the overlay, or create it if it does not exit." + (if (and yas/active-field-overlay + (overlay-buffer yas/active-field-overlay)) + (move-overlay yas/active-field-overlay + (yas/field-start field) + (yas/field-end field)) + (setq yas/active-field-overlay + (make-overlay (yas/field-start field) + (yas/field-end field) + nil nil t)) + (overlay-put yas/active-field-overlay 'priority 100) + (overlay-put yas/active-field-overlay 'face 'yas/field-highlight-face) + (overlay-put yas/active-field-overlay 'yas/snippet snippet) + (overlay-put yas/active-field-overlay 'modification-hooks '(yas/on-field-overlay-modification)) + (overlay-put yas/active-field-overlay 'insert-in-front-hooks + '(yas/on-field-overlay-modification)) + (overlay-put yas/active-field-overlay 'insert-behind-hooks + '(yas/on-field-overlay-modification)))) + +(defun yas/on-field-overlay-modification (overlay after? beg end &optional length) + "Clears the field and updates mirrors, conditionally. + +Only clears the field if it hasn't been modified and it point it +at field start. This hook doesn't do anything if an undo is in +progress." + (unless (yas/undo-in-progress) + (let ((field (overlay-get yas/active-field-overlay 'yas/field))) + (cond (after? + (yas/advance-end-maybe field (overlay-end overlay)) +;;; primary field transform: normal calls to expression + (let ((saved-point (point))) + (yas/field-update-display field (car (yas/snippets-at-point))) + (goto-char saved-point)) + (yas/update-mirrors (car (yas/snippets-at-point)))) + (field + (when (and (not after?) + (not (yas/field-modified-p field)) + (eq (point) (if (markerp (yas/field-start field)) + (marker-position (yas/field-start field)) + (yas/field-start field)))) + (yas/skip-and-clear field)) + (setf (yas/field-modified-p field) t)))))) + +;;; Apropos protection overlays: +;;; +;;; These exist for nasty users who will try to delete parts of the +;;; snippet outside the active field. Actual protection happens in +;;; `yas/on-protection-overlay-modification'. +;;; +;;; Currently this signals an error which inhibits the command. For +;;; commands that move point (like `kill-line'), point is restored in +;;; the `yas/post-command-handler' using a global +;;; `yas/protection-violation' variable. +;;; +;;; Alternatively, I've experimented with an implementation that +;;; commits the snippet before actually calling `this-command' +;;; interactively, and then signals an eror, which is ignored. but +;;; blocks all other million modification hooks. This presented some +;;; problems with stacked expansion. +;;; + +(defun yas/make-move-field-protection-overlays (snippet field) + "Place protection overlays surrounding SNIPPET's FIELD. + +Move the overlays, or create them if they do not exit." + (let ((start (yas/field-start field)) + (end (yas/field-end field))) + ;; First check if the (1+ end) is contained in the buffer, + ;; otherwise we'll have to do a bit of cheating and silently + ;; insert a newline. the `(1+ (buffer-size))' should prevent this + ;; when using stacked expansion + ;; + (when (< (buffer-size) end) + (save-excursion + (let ((inhibit-modification-hooks t)) + (goto-char (point-max)) + (newline)))) + ;; go on to normal overlay creation/moving + ;; + (cond ((and yas/field-protection-overlays + (every #'overlay-buffer yas/field-protection-overlays)) + (move-overlay (first yas/field-protection-overlays) (1- start) start) + (move-overlay (second yas/field-protection-overlays) end (1+ end))) + (t + (setq yas/field-protection-overlays + (list (make-overlay (1- start) start nil t nil) + (make-overlay end (1+ end) nil t nil))) + (dolist (ov yas/field-protection-overlays) + (overlay-put ov 'face 'yas/field-debug-face) + (overlay-put ov 'yas/snippet snippet) + ;; (overlay-put ov 'evaporate t) + (overlay-put ov 'modification-hooks '(yas/on-protection-overlay-modification))))))) + +(defvar yas/protection-violation nil + "When non-nil, signals attempts to erronesly exit or modify the snippet. + +Functions in the `post-command-hook', for example +`yas/post-command-handler' can check it and reset its value to +nil. The variables value is the point where the violation +originated") + +(defun yas/on-protection-overlay-modification (overlay after? beg end &optional length) + "Signals a snippet violation, then issues error. + +The error should be ignored in `debug-ignored-errors'" + (cond ((not (or after? + (yas/undo-in-progress))) + (setq yas/protection-violation (point)) + (error "Exit the snippet first!")))) + +(add-to-list 'debug-ignored-errors "^Exit the snippet first!$") + + +;;; Apropos stacked expansion: +;;; +;;; the parent snippet does not run its fields modification hooks +;;; (`yas/on-field-overlay-modification' and +;;; `yas/on-protection-overlay-modification') while the child snippet +;;; is active. This means, among other things, that the mirrors of the +;;; parent snippet are not updated, this only happening when one exits +;;; the child snippet. +;;; +;;; Unfortunately, this also puts some ugly (and not fully-tested) +;;; bits of code in `yas/expand-snippet' and +;;; `yas/commit-snippet'. I've tried to mark them with "stacked +;;; expansion:". +;;; +;;; This was thought to be safer in in an undo/redo perpective, but +;;; maybe the correct implementation is to make the globals +;;; `yas/active-field-overlay' and `yas/field-protection-overlays' be +;;; snippet-local and be active even while the child snippet is +;;; running. This would mean a lot of overlay modification hooks +;;; running, but if managed correctly (including overlay priorities) +;;; they should account for all situations... +;;; + +(defun yas/expand-snippet (template &optional start end expand-env) + "Expand snippet at current point. Text between START and END +will be deleted before inserting template." + (run-hooks 'yas/before-expand-snippet-hook) + + ;; If a region is active, set `yas/selected-text' + (setq yas/selected-text + (when mark-active + (prog1 (buffer-substring-no-properties (region-beginning) + (region-end)) + (unless start (setq start (region-beginning)) + (unless end (setq end (region-end))))))) + + (when start + (goto-char start)) + + ;; stacked expansion: shoosh the overlay modification hooks + ;; + (let ((to-delete (and start end (buffer-substring-no-properties start end))) + (start (or start (point))) + (end (or end (point))) + (inhibit-modification-hooks t) + (column (current-column)) + snippet) + + ;; Delete the region to delete, this *does* get undo-recorded. + ;; + (when (and to-delete + (> end start)) + (delete-region start end) + (setq yas/deleted-text to-delete)) + + ;; Narrow the region down to the template, shoosh the + ;; `buffer-undo-list', and create the snippet, the new snippet + ;; updates its mirrors once, so we are left with some plain text. + ;; The undo action for deleting this plain text will get recorded + ;; at the end of this function. + (save-restriction + (narrow-to-region start start) + (let ((buffer-undo-list t)) + ;; snippet creation might evaluate users elisp, which + ;; might generate errors, so we have to be ready to catch + ;; them mostly to make the undo information + ;; + (setq yas/start-column (save-restriction (widen) (current-column))) + (insert template) + + (setq snippet + (if expand-env + (let ((read-vars (condition-case err + (read expand-env) + (error nil)))) + (eval `(let ,read-vars + (yas/snippet-create (point-min) (point-max))))) + (yas/snippet-create (point-min) (point-max)))))) + + ;; stacked-expansion: This checks for stacked expansion, save the + ;; `yas/previous-active-field' and advance its boudary. + ;; + (let ((existing-field (and yas/active-field-overlay + (overlay-buffer yas/active-field-overlay) + (overlay-get yas/active-field-overlay 'yas/field)))) + (when existing-field + (setf (yas/snippet-previous-active-field snippet) existing-field) + (yas/advance-end-maybe existing-field (overlay-end yas/active-field-overlay)))) + + ;; Exit the snippet immediately if no fields + ;; + (unless (yas/snippet-fields snippet) + (yas/exit-snippet snippet)) + + ;; Push two undo actions: the deletion of the inserted contents of + ;; the new snippet (without the "key") followed by an apply of + ;; `yas/take-care-of-redo' on the newly inserted snippet boundaries + ;; + (let ((start (overlay-start (yas/snippet-control-overlay snippet))) + (end (overlay-end (yas/snippet-control-overlay snippet)))) + (push (cons start end) buffer-undo-list) + (push `(apply yas/take-care-of-redo ,start ,end ,snippet) + buffer-undo-list)) + ;; Now, move to the first field + ;; + (let ((first-field (car (yas/snippet-fields snippet)))) + (when first-field + (yas/move-to-field snippet first-field)))) + (message "[yas] snippet expanded.")) + +(defun yas/take-care-of-redo (beg end snippet) + "Commits SNIPPET, which in turn pushes an undo action for +reviving it. + +Meant to exit in the `buffer-undo-list'." + ;; slightly optimize: this action is only needed for snippets with + ;; at least one field + (when (yas/snippet-fields snippet) + (yas/commit-snippet snippet 'no-hooks))) + +(defun yas/snippet-revive (beg end snippet) + "Revives the SNIPPET and creates a control overlay from BEG to +END. + +BEG and END are, we hope, the original snippets boudaries. All +the markers/points exiting existing inside SNIPPET should point +to their correct locations *at the time the snippet is revived*. + +After revival, push the `yas/take-care-of-redo' in the +`buffer-undo-list'" + ;; Reconvert all the points to markers + ;; + (yas/points-to-markers snippet) + ;; When at least one editable field existed in the zombie snippet, + ;; try to revive the whole thing... + ;; + (let ((target-field (or (yas/snippet-active-field snippet) + (car (yas/snippet-fields snippet))))) + (when target-field + (setf (yas/snippet-control-overlay snippet) (yas/make-control-overlay snippet beg end)) + (overlay-put (yas/snippet-control-overlay snippet) 'yas/snippet snippet) + + (yas/move-to-field snippet target-field) + + (add-hook 'post-command-hook 'yas/post-command-handler nil t) + (add-hook 'pre-command-hook 'yas/pre-command-handler t t) + + (push `(apply yas/take-care-of-redo ,beg ,end ,snippet) + buffer-undo-list)))) + +(defun yas/snippet-create (begin end) + "Creates a snippet from an template inserted between BEGIN and END. + +Returns the newly created snippet." + (let ((snippet (yas/make-snippet))) + (goto-char begin) + (yas/snippet-parse-create snippet) + + ;; Sort and link each field + (yas/snippet-sort-fields snippet) + + ;; Create keymap overlay for snippet + (setf (yas/snippet-control-overlay snippet) + (yas/make-control-overlay snippet (point-min) (point-max))) + + ;; Move to end + (goto-char (point-max)) + + ;; Setup hooks + (add-hook 'post-command-hook 'yas/post-command-handler nil t) + (add-hook 'pre-command-hook 'yas/pre-command-handler t t) + + snippet)) + + +;;; Apropos adjacencies: Once the $-constructs bits like "$n" and +;;; "${:n" are deleted in the recently expanded snippet, we might +;;; actually have many fields, mirrors (and the snippet exit) in the +;;; very same position in the buffer. Therefore we need to single-link +;;; the fields-or-mirrors-or-exit, which I have called "fom", +;;; according to their original positions in the buffer. +;;; +;;; Then we have operation `yas/advance-end-maybe' and +;;; `yas/advance-start-maybe', which conditionally push the starts and +;;; ends of these foms down the chain. +;;; +;;; This allows for like the printf with the magic ",": +;;; +;;; printf ("${1:%s}\\n"${1:$(if (string-match "%" text) "," "\);")} \ +;;; $2${1:$(if (string-match "%" text) "\);" "")}$0 +;;; + +(defun yas/fom-start (fom) + (cond ((yas/field-p fom) + (yas/field-start fom)) + ((yas/mirror-p fom) + (yas/mirror-start fom)) + (t + (yas/exit-marker fom)))) + +(defun yas/fom-end (fom) + (cond ((yas/field-p fom) + (yas/field-end fom)) + ((yas/mirror-p fom) + (yas/mirror-end fom)) + (t + (yas/exit-marker fom)))) + +(defun yas/fom-next (fom) + (cond ((yas/field-p fom) + (yas/field-next fom)) + ((yas/mirror-p fom) + (yas/mirror-next fom)) + (t + (yas/exit-next fom)))) + +(defun yas/calculate-adjacencies (snippet) + "Calculate adjacencies for fields or mirrors of SNIPPET. + +This is according to their relative positions in the buffer, and +has to be called before the $-constructs are deleted." + (flet ((yas/fom-set-next-fom (fom nextfom) + (cond ((yas/field-p fom) + (setf (yas/field-next fom) nextfom)) + ((yas/mirror-p fom) + (setf (yas/mirror-next fom) nextfom)) + (t + (setf (yas/exit-next fom) nextfom)))) + (yas/compare-fom-begs (fom1 fom2) + (> (yas/fom-start fom2) (yas/fom-start fom1))) + (yas/link-foms (fom1 fom2) + (yas/fom-set-next-fom fom1 fom2))) + ;; make some yas/field, yas/mirror and yas/exit soup + (let ((soup)) + (when (yas/snippet-exit snippet) + (push (yas/snippet-exit snippet) soup)) + (dolist (field (yas/snippet-fields snippet)) + (push field soup) + (dolist (mirror (yas/field-mirrors field)) + (push mirror soup))) + (setq soup + (sort soup + #'yas/compare-fom-begs)) + (when soup + (reduce #'yas/link-foms soup))))) + +(defun yas/advance-end-maybe (fom newend) + "Maybe advance FOM's end to NEWEND if it needs it. + +If it does, also: + +* call `yas/advance-start-maybe' on FOM's next fom. + +* in case FOM is field call `yas/advance-end-maybe' on its parent + field" + (when (and fom (< (yas/fom-end fom) newend)) + (set-marker (yas/fom-end fom) newend) + (yas/advance-start-maybe (yas/fom-next fom) newend) + (if (and (yas/field-p fom) + (yas/field-parent-field fom)) + (yas/advance-end-maybe (yas/field-parent-field fom) newend)))) + +(defun yas/advance-start-maybe (fom newstart) + "Maybe advance FOM's start to NEWSTART if it needs it. + +If it does, also call `yas/advance-end-maybe' on FOM." + (when (and fom (< (yas/fom-start fom) newstart)) + (set-marker (yas/fom-start fom) newstart) + (yas/advance-end-maybe fom newstart))) + +(defvar yas/dollar-regions nil + "When expanding the snippet the \"parse-create\" functions add + cons cells to this var") + +(defun yas/snippet-parse-create (snippet) + "Parse a recently inserted snippet template, creating all +necessary fields, mirrors and exit points. + +Meant to be called in a narrowed buffer, does various passes" + (let ((parse-start (point))) + ;; Reset the yas/dollar-regions + ;; + (setq yas/dollar-regions nil) + ;; protect escaped quote, backquotes and backslashes + ;; + (yas/protect-escapes nil '(?\\ ?` ?')) + ;; replace all backquoted expressions + ;; + (goto-char parse-start) + (yas/replace-backquotes) + ;; protect escapes again since previous steps might have generated + ;; more characters needing escaping + ;; + (goto-char parse-start) + (yas/protect-escapes) + ;; parse fields with {} + ;; + (goto-char parse-start) + (yas/field-parse-create snippet) + ;; parse simple mirrors and fields + ;; + (goto-char parse-start) + (yas/simple-mirror-parse-create snippet) + ;; parse mirror transforms + ;; + (goto-char parse-start) + (yas/transform-mirror-parse-create snippet) + ;; calculate adjacencies of fields and mirrors + ;; + (yas/calculate-adjacencies snippet) + ;; Delete $-constructs + ;; + (yas/delete-regions yas/dollar-regions) + ;; restore escapes + ;; + (goto-char parse-start) + (yas/restore-escapes) + ;; update mirrors for the first time + ;; + (yas/update-mirrors snippet) + ;; indent the best we can + ;; + (goto-char parse-start) + (yas/indent snippet))) + +(defun yas/indent-according-to-mode (snippet-markers) + "Indent current line according to mode, preserving +SNIPPET-MARKERS." + ;; XXX: Here seems to be the indent problem: + ;; + ;; `indent-according-to-mode' uses whatever + ;; `indent-line-function' is available. Some + ;; implementations of these functions delete text + ;; before they insert. If there happens to be a marker + ;; just after the text being deleted, the insertion + ;; actually happens after the marker, which misplaces + ;; it. + ;; + ;; This would also happen if we had used overlays with + ;; the `front-advance' property set to nil. + ;; + ;; This is why I have these `trouble-markers', they are the ones at + ;; they are the ones at the first non-whitespace char at the line + ;; (i.e. at `yas/real-line-beginning'. After indentation takes place + ;; we should be at the correct to restore them to. All other + ;; non-trouble-markers have been *pushed* and don't need special + ;; attention. + ;; + (goto-char (yas/real-line-beginning)) + (let ((trouble-markers (remove-if-not #'(lambda (marker) + (= marker (point))) + snippet-markers))) + (save-restriction + (widen) + (condition-case err + (indent-according-to-mode) + (error (message "[yas] warning: yas/indent-according-to-mode habing problems running %s" indent-line-function) + nil))) + (mapc #'(lambda (marker) + (set-marker marker (point))) + trouble-markers))) + +(defun yas/indent (snippet) + (let ((snippet-markers (yas/collect-snippet-markers snippet))) + ;; Look for those $> + (save-excursion + (while (re-search-forward "$>" nil t) + (delete-region (match-beginning 0) (match-end 0)) + (when (not (eq yas/indent-line 'auto)) + (yas/indent-according-to-mode snippet-markers)))) + ;; Now do stuff for 'fixed and 'auto + (save-excursion + (cond ((eq yas/indent-line 'fixed) + (while (and (zerop (forward-line)) + (zerop (current-column))) + (indent-to-column column))) + ((eq yas/indent-line 'auto) + (let ((end (set-marker (make-marker) (point-max))) + (indent-first-line-p yas/also-auto-indent-first-line)) + (while (and (zerop (if indent-first-line-p + (prog1 + (forward-line 0) + (setq indent-first-line-p nil)) + (forward-line 1))) + (not (eobp)) + (<= (point) end)) + (yas/indent-according-to-mode snippet-markers)))) + (t + nil))))) + +(defun yas/collect-snippet-markers (snippet) + "Make a list of all the markers used by SNIPPET." + (let (markers) + (dolist (field (yas/snippet-fields snippet)) + (push (yas/field-start field) markers) + (push (yas/field-end field) markers) + (dolist (mirror (yas/field-mirrors field)) + (push (yas/mirror-start mirror) markers) + (push (yas/mirror-end mirror) markers))) + (let ((snippet-exit (yas/snippet-exit snippet))) + (when (and snippet-exit + (marker-buffer (yas/exit-marker snippet-exit))) + (push (yas/exit-marker snippet-exit) markers))) + markers)) + +(defun yas/real-line-beginning () + (let ((c (char-after (line-beginning-position))) + (n (line-beginning-position))) + (while (or (eql c ?\ ) + (eql c ?\t)) + (incf n) + (setq c (char-after n))) + n)) + +(defun yas/escape-string (escaped) + (concat "YASESCAPE" (format "%d" escaped) "PROTECTGUARD")) + +(defun yas/protect-escapes (&optional text escaped) + "Protect all escaped characters with their numeric ASCII value. + +With optional string TEXT do it in string instead of buffer." + (let ((changed-text text) + (text-provided-p text)) + (mapc #'(lambda (escaped) + (setq changed-text + (yas/replace-all (concat "\\" (char-to-string escaped)) + (yas/escape-string escaped) + (when text-provided-p changed-text)))) + (or escaped yas/escaped-characters)) + changed-text)) + +(defun yas/restore-escapes (&optional text escaped) + "Restore all escaped characters from their numeric ASCII value. + +With optional string TEXT do it in string instead of the buffer." + (let ((changed-text text) + (text-provided-p text)) + (mapc #'(lambda (escaped) + (setq changed-text + (yas/replace-all (yas/escape-string escaped) + (char-to-string escaped) + (when text-provided-p changed-text)))) + (or escaped yas/escaped-characters)) + changed-text)) + +(defun yas/replace-backquotes () + "Replace all the \"`(lisp-expression)`\"-style expression + with their evaluated value" + (while (re-search-forward yas/backquote-lisp-expression-regexp nil t) + (let ((transformed (yas/read-and-eval-string (yas/restore-escapes (match-string 1))))) + (goto-char (match-end 0)) + (when transformed (insert transformed)) + (delete-region (match-beginning 0) (match-end 0))))) + +(defun yas/scan-sexps (from count) + (condition-case err + (with-syntax-table (standard-syntax-table) + (scan-sexps from count)) + (error + nil))) + +(defun yas/make-marker (pos) + "Create a marker at POS with `nil' `marker-insertion-type'" + (let ((marker (set-marker (make-marker) pos))) + (set-marker-insertion-type marker nil) + marker)) + +(defun yas/field-parse-create (snippet &optional parent-field) + "Parse most field expressions, except for the simple one \"$n\". + +The following count as a field: + +* \"${n: text}\", for a numbered field with default text, as long as N is not 0; + +* \"${n: text$(expression)}, the same with a lisp expression; + this is caught with the curiously named `yas/multi-dollar-lisp-expression-regexp' + +* the same as above but unnumbered, (no N:) and number is calculated automatically. + +When multiple expressions are found, only the last one counts." + ;; + (save-excursion + (while (re-search-forward yas/field-regexp nil t) + (let* ((real-match-end-0 (yas/scan-sexps (1+ (match-beginning 0)) 1)) + (number (and (match-string-no-properties 1) + (string-to-number (match-string-no-properties 1)))) + (brand-new-field (and real-match-end-0 + ;; break if on "$(" immediately + ;; after the ":", this will be + ;; caught as a mirror with + ;; transform later. + (not (save-match-data + (eq (string-match "$[ \t\n]*(" + (match-string-no-properties 2)) 0))) + (not (and number (zerop number))) + (yas/make-field number + (yas/make-marker (match-beginning 2)) + (yas/make-marker (1- real-match-end-0)) + parent-field)))) + (when brand-new-field + (goto-char real-match-end-0) + (push (cons (1- real-match-end-0) real-match-end-0) + yas/dollar-regions) + (push (cons (match-beginning 0) (match-beginning 2)) + yas/dollar-regions) + (push brand-new-field (yas/snippet-fields snippet)) + (save-excursion + (save-restriction + (narrow-to-region (yas/field-start brand-new-field) (yas/field-end brand-new-field)) + (goto-char (point-min)) + (yas/field-parse-create snippet brand-new-field))))))) + ;; if we entered from a parent field, now search for the + ;; `yas/multi-dollar-lisp-expression-regexp'. THis is used for + ;; primary field transformations + ;; + (when parent-field + (save-excursion + (while (re-search-forward yas/multi-dollar-lisp-expression-regexp nil t) + (let* ((real-match-end-1 (yas/scan-sexps (match-beginning 1) 1))) + ;; commit the primary field transformation if we don't find + ;; it in yas/dollar-regions (a subnested field) might have + ;; already caught it. + (when (and real-match-end-1 + (not (member (cons (match-beginning 0) + real-match-end-1) + yas/dollar-regions))) + (let ((lisp-expression-string (buffer-substring-no-properties (match-beginning 1) + real-match-end-1))) + (setf (yas/field-transform parent-field) (yas/restore-escapes lisp-expression-string))) + (push (cons (match-beginning 0) real-match-end-1) + yas/dollar-regions))))))) + +(defun yas/transform-mirror-parse-create (snippet) + "Parse the \"${n:$(lisp-expression)}\" mirror transformations." + (while (re-search-forward yas/transform-mirror-regexp nil t) + (let* ((real-match-end-0 (yas/scan-sexps (1+ (match-beginning 0)) 1)) + (number (string-to-number (match-string-no-properties 1))) + (field (and number + (not (zerop number)) + (yas/snippet-find-field snippet number)))) + (when (and real-match-end-0 + field) + (push (yas/make-mirror (yas/make-marker (match-beginning 0)) + (yas/make-marker (match-beginning 0)) + (yas/restore-escapes + (buffer-substring-no-properties (match-beginning 2) + (1- real-match-end-0)))) + (yas/field-mirrors field)) + (push (cons (match-beginning 0) real-match-end-0) yas/dollar-regions))))) + +(defun yas/simple-mirror-parse-create (snippet) + "Parse the simple \"$n\" mirrors and the exit-marker." + (while (re-search-forward yas/simple-mirror-regexp nil t) + (let ((number (string-to-number (match-string-no-properties 1)))) + (cond ((zerop number) + + (setf (yas/snippet-exit snippet) + (yas/make-exit (yas/make-marker (match-end 0)))) + (save-excursion + (goto-char (match-beginning 0)) + (when yas/wrap-around-region + (cond (yas/selected-text + (insert yas/selected-text)) + ((and (eq yas/wrap-around-region 'cua) + cua-mode + (get-register ?0)) + (insert (prog1 (get-register ?0) + (set-register ?0 nil)))))) + (push (cons (point) (yas/exit-marker (yas/snippet-exit snippet))) + yas/dollar-regions))) + (t + (let ((field (yas/snippet-find-field snippet number))) + (if field + (push (yas/make-mirror (yas/make-marker (match-beginning 0)) + (yas/make-marker (match-beginning 0)) + nil) + (yas/field-mirrors field)) + (push (yas/make-field number + (yas/make-marker (match-beginning 0)) + (yas/make-marker (match-beginning 0)) + nil) + (yas/snippet-fields snippet)))) + (push (cons (match-beginning 0) (match-end 0)) + yas/dollar-regions)))))) + +(defun yas/delete-regions (regions) + "Sort disjuct REGIONS by start point, then delete from the back." + (mapc #'(lambda (reg) + (delete-region (car reg) (cdr reg))) + (sort regions + #'(lambda (r1 r2) + (>= (car r1) (car r2)))))) + +(defun yas/update-mirrors (snippet) + "Updates all the mirrors of SNIPPET." + (save-excursion + (dolist (field (yas/snippet-fields snippet)) + (dolist (mirror (yas/field-mirrors field)) + ;; stacked expansion: I added an `inhibit-modification-hooks' + ;; here, for safety, may need to remove if we the mechanism is + ;; altered. + ;; + (let ((inhibit-modification-hooks t)) + (yas/mirror-update-display mirror field) + ;; `yas/place-overlays' is needed if the active field and + ;; protected overlays have been changed because of insertions + ;; in `yas/mirror-update-display' + ;; + (when (eq field (yas/snippet-active-field snippet)) + (yas/place-overlays snippet field))))))) + +(defun yas/mirror-update-display (mirror field) + "Update MIRROR according to FIELD (and mirror transform)." + (let ((reflection (or (yas/apply-transform mirror field) + (yas/field-text-for-display field)))) + (when (and reflection + (not (string= reflection (buffer-substring-no-properties (yas/mirror-start mirror) + (yas/mirror-end mirror))))) + (goto-char (yas/mirror-start mirror)) + (insert reflection) + (if (> (yas/mirror-end mirror) (point)) + (delete-region (point) (yas/mirror-end mirror)) + (set-marker (yas/mirror-end mirror) (point)) + (yas/advance-start-maybe (yas/mirror-next mirror) (point)))))) + +(defun yas/field-update-display (field snippet) + "Much like `yas/mirror-update-display', but for fields" + (when (yas/field-transform field) + (let ((inhibit-modification-hooks t) + (transformed (yas/apply-transform field field)) + (point (point))) + (when (and transformed + (not (string= transformed (buffer-substring-no-properties (yas/field-start field) + (yas/field-end field))))) + (setf (yas/field-modified-p field) t) + (goto-char (yas/field-start field)) + (insert transformed) + (if (> (yas/field-end field) (point)) + (delete-region (point) (yas/field-end field)) + (set-marker (yas/field-end field) (point)) + (yas/advance-start-maybe (yas/field-next field) (point))) + t)))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Pre- and post-command hooks +;; +(defun yas/pre-command-handler () ) + +(defun yas/post-command-handler () + "Handles various yasnippet conditions after each command." + (cond (yas/protection-violation + (goto-char yas/protection-violation) + (setq yas/protection-violation nil)) + ((eq 'undo this-command) + ;; + ;; After undo revival the correct field is sometimes not + ;; restored correctly, this condition handles that + ;; + (let* ((snippet (car (yas/snippets-at-point))) + (target-field (and snippet + (find-if-not #'(lambda (field) + (yas/field-probably-deleted-p snippet field)) + (remove nil + (cons (yas/snippet-active-field snippet) + (yas/snippet-fields snippet))))))) + (when target-field + (yas/move-to-field snippet target-field)))) + ((not (yas/undo-in-progress)) + ;; When not in an undo, check if we must commit the snippet (use exited it). + (yas/check-commit-snippet)))) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Debug functions. Use (or change) at will whenever needed. +;; +;; some useful debug code for looking up snippet tables +;; +;; (insert (pp +;; (let ((shit)) +;; (maphash #'(lambda (k v) +;; (push k shit)) +;; (yas/snippet-table-hash (gethash 'ruby-mode yas/snippet-tables))) +;; shit))) +;; + +(defun yas/debug-tables () + (interactive) + (with-output-to-temp-buffer "*YASnippet tables*" + (dolist (symbol (remove nil (append (list major-mode) + (if (listp yas/mode-symbol) + yas/mode-symbol + (list yas/mode-symbol))))) + (princ (format "Snippet table hash keys for %s:\n\n" symbol)) + (let ((keys)) + (maphash #'(lambda (k v) + (push k keys)) + (yas/snippet-table-hash (gethash symbol yas/snippet-tables))) + (princ keys)) + + (princ (format "Keymap for %s:\n\n" symbol)) + (princ (gethash symbol yas/menu-table))))) + +(defun yas/debug-snippet-vars () + "Debug snippets, fields, mirrors and the `buffer-undo-list'." + (interactive) + (with-output-to-temp-buffer "*YASnippet trace*" + (princ "Interesting YASnippet vars: \n\n") + + (princ (format "\nPost command hook: %s\n" post-command-hook)) + (princ (format "\nPre command hook: %s\n" pre-command-hook)) + + (princ (format "%s live snippets in total\n" (length (yas/snippets-at-point (quote all-snippets))))) + (princ (format "%s overlays in buffer:\n\n" (length (overlays-in (point-min) (point-max))))) + (princ (format "%s live snippets at point:\n\n" (length (yas/snippets-at-point)))) + + + (dolist (snippet (yas/snippets-at-point)) + (princ (format "\tsid: %d control overlay from %d to %d\n" + (yas/snippet-id snippet) + (overlay-start (yas/snippet-control-overlay snippet)) + (overlay-end (yas/snippet-control-overlay snippet)))) + (princ (format "\tactive field: %d from %s to %s covering \"%s\"\n" + (yas/field-number (yas/snippet-active-field snippet)) + (marker-position (yas/field-start (yas/snippet-active-field snippet))) + (marker-position (yas/field-end (yas/snippet-active-field snippet))) + (buffer-substring-no-properties (yas/field-start (yas/snippet-active-field snippet)) (yas/field-end (yas/snippet-active-field snippet))))) + (when (yas/snippet-exit snippet) + (princ (format "\tsnippet-exit: at %s next: %s\n" + (yas/exit-marker (yas/snippet-exit snippet)) + (yas/exit-next (yas/snippet-exit snippet))))) + (dolist (field (yas/snippet-fields snippet)) + (princ (format "\tfield: %d from %s to %s covering \"%s\" next: %s\n" + (yas/field-number field) + (marker-position (yas/field-start field)) + (marker-position (yas/field-end field)) + (buffer-substring-no-properties (yas/field-start field) (yas/field-end field)) + (yas/debug-format-fom-concise (yas/field-next field)))) + (dolist (mirror (yas/field-mirrors field)) + (princ (format "\t\tmirror: from %s to %s covering \"%s\" next: %s\n" + (marker-position (yas/mirror-start mirror)) + (marker-position (yas/mirror-end mirror)) + (buffer-substring-no-properties (yas/mirror-start mirror) (yas/mirror-end mirror)) + (yas/debug-format-fom-concise (yas/mirror-next mirror))))))) + + (princ (format "\nUndo is %s and point-max is %s.\n" + (if (eq buffer-undo-list t) + "DISABLED" + "ENABLED") + (point-max))) + (unless (eq buffer-undo-list t) + (princ (format "Undpolist has %s elements. First 10 elements follow:\n" (length buffer-undo-list))) + (let ((first-ten (subseq buffer-undo-list 0 19))) + (dolist (undo-elem first-ten) + (princ (format "%2s: %s\n" (position undo-elem first-ten) (truncate-string-to-width (format "%s" undo-elem) 70)))))))) + +(defun yas/debug-format-fom-concise (fom) + (when fom + (cond ((yas/field-p fom) + (format "field %d from %d to %d" + (yas/field-number fom) + (marker-position (yas/field-start fom)) + (marker-position (yas/field-end fom)))) + ((yas/mirror-p fom) + (format "mirror from %d to %d" + (marker-position (yas/mirror-start fom)) + (marker-position (yas/mirror-end fom)))) + (t + (format "snippet exit at %d" + (marker-position (yas/fom-start fom))))))) + + +(defun yas/exterminate-package () + (interactive) + (yas/global-mode -1) + (yas/minor-mode -1) + (yas/kill-snippet-keybindings) + (mapatoms #'(lambda (atom) + (when (string-match "yas/" (symbol-name atom)) + (unintern atom))))) + +(defun yas/debug-test (&optional quiet) + (interactive "P") + (yas/load-directory (or (and (listp yas/root-directory) + (first yas/root-directory)) + yas/root-directory + "~/Source/yasnippet/snippets/")) + (set-buffer (switch-to-buffer "*YAS TEST*")) + (mapc #'yas/commit-snippet (yas/snippets-at-point 'all-snippets)) + (erase-buffer) + (setq buffer-undo-list nil) + (setq undo-in-progress nil) + (snippet-mode) + (yas/minor-mode 1) + (let ((abbrev)) + (setq abbrev "$f") + (insert abbrev)) + (unless quiet + (add-hook 'post-command-hook 'yas/debug-snippet-vars 't 'local))) + + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; `locate-dominating-file' is added for compatibility in emacs < 23 +(unless (or (eq emacs-major-version 23) + (fboundp 'locate-dominating-file)) + (defvar locate-dominating-stop-dir-regexp + "\\`\\(?:[\\/][\\/][^\\/]+[\\/]\\|/\\(?:net\\|afs\\|\\.\\.\\.\\)/\\)\\'" + "Regexp of directory names which stop the search in `locate-dominating-file'. +Any directory whose name matches this regexp will be treated like +a kind of root directory by `locate-dominating-file' which will stop its search +when it bumps into it. +The default regexp prevents fruitless and time-consuming attempts to find +special files in directories in which filenames are interpreted as hostnames, +or mount points potentially requiring authentication as a different user.") + + (defun locate-dominating-file (file name) + "Look up the directory hierarchy from FILE for a file named NAME. +Stop at the first parent directory containing a file NAME, +and return the directory. Return nil if not found." + ;; We used to use the above locate-dominating-files code, but the + ;; directory-files call is very costly, so we're much better off doing + ;; multiple calls using the code in here. + ;; + ;; Represent /home/luser/foo as ~/foo so that we don't try to look for + ;; `name' in /home or in /. + (setq file (abbreviate-file-name file)) + (let ((root nil) + (prev-file file) + ;; `user' is not initialized outside the loop because + ;; `file' may not exist, so we may have to walk up part of the + ;; hierarchy before we find the "initial UID". + (user nil) + try) + (while (not (or root + (null file) + ;; FIXME: Disabled this heuristic because it is sometimes + ;; inappropriate. + ;; As a heuristic, we stop looking up the hierarchy of + ;; directories as soon as we find a directory belonging + ;; to another user. This should save us from looking in + ;; things like /net and /afs. This assumes that all the + ;; files inside a project belong to the same user. + ;; (let ((prev-user user)) + ;; (setq user (nth 2 (file-attributes file))) + ;; (and prev-user (not (equal user prev-user)))) + (string-match locate-dominating-stop-dir-regexp file))) + (setq try (file-exists-p (expand-file-name name file))) + (cond (try (setq root file)) + ((equal file (setq prev-file file + file (file-name-directory + (directory-file-name file)))) + (setq file nil)))) + root))) + +(provide 'yasnippet) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; Monkey patching for other functions that's causing +;; problems to yasnippet. For details on why I patch +;; those functions, refer to +;; http://code.google.com/p/yasnippet/wiki/MonkeyPatching +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defadvice c-neutralize-syntax-in-CPP + (around yas-mp/c-neutralize-syntax-in-CPP activate) + "Adviced `c-neutralize-syntax-in-CPP' to properly +handle the end-of-buffer error fired in it by calling +`forward-char' at the end of buffer." + (condition-case err + ad-do-it + (error (message (error-message-string err))))) + +;; disable c-electric-* serial command in YAS fields +(add-hook 'c-mode-common-hook + '(lambda () + (dolist (k '(":" ">" ";" "<" "{" "}")) + (define-key (symbol-value (make-local-variable 'yas/keymap)) + k 'self-insert-command)))) + + +;;; yasnippet.el ends here + +;;; dropdown-list.el --- Drop-down menu interface +;; +;; Filename: dropdown-list.el +;; Description: Drop-down menu interface +;; Author: Jaeyoun Chung [jay.chung@gmail.com] +;; Maintainer: +;; Copyright (C) 2008 Jaeyoun Chung +;; Created: Sun Mar 16 11:20:45 2008 (Pacific Daylight Time) +;; Version: +;; Last-Updated: Sun Mar 16 12:19:49 2008 (Pacific Daylight Time) +;; By: dradams +;; Update #: 43 +;; URL: http://www.emacswiki.org/cgi-bin/wiki/dropdown-list.el +;; Keywords: convenience menu +;; Compatibility: GNU Emacs 21.x, GNU Emacs 22.x +;; +;; Features that might be required by this library: +;; +;; `cl'. +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;;; Commentary: +;; +;; According to Jaeyoun Chung, "overlay code stolen from company-mode.el." +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;;; Change log: +;; +;; 2008/03/16 dadams +;; Clean-up - e.g. use char-to-string for control chars removed by email posting. +;; Moved example usage code (define-key*, command-selector) inside the library. +;; Require cl.el at byte-compile time. +;; Added GPL statement. +;; 2008/01/06 Jaeyoun Chung +;; Posted to gnu-emacs-sources@gnu.org at 9:10 p.m. +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;; 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, 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; see the file COPYING. If not, write to +;; the Free Software Foundation, Inc., 51 Franklin Street, Fifth +;; Floor, Boston, MA 02110-1301, USA. +;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;; +;;; Code: + +(eval-when-compile (require 'cl)) ;; decf, fourth, incf, loop, mapcar* + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; + +(defface dropdown-list-face + '((t :inherit default :background "lightyellow" :foreground "black")) + "*Bla." :group 'dropdown-list) + +(defface dropdown-list-selection-face + '((t :inherit dropdown-list-face :background "purple")) + "*Bla." :group 'dropdown-list) + +(defvar dropdown-list-overlays nil) + +(defun dropdown-list-hide () + (while dropdown-list-overlays + (delete-overlay (pop dropdown-list-overlays)))) + +(defun dropdown-list-put-overlay (beg end &optional prop value prop2 value2) + (let ((ov (make-overlay beg end))) + (overlay-put ov 'window t) + (when prop + (overlay-put ov prop value) + (when prop2 (overlay-put ov prop2 value2))) + ov)) + +(defun dropdown-list-line (start replacement &optional no-insert) + ;; start might be in the middle of a tab, which means we need to hide the + ;; tab and add spaces + (let ((end (+ start (length replacement))) + beg-point end-point + before-string after-string) + (goto-char (point-at-eol)) + (if (< (current-column) start) + (progn (setq before-string (make-string (- start (current-column)) ? )) + (setq beg-point (point))) + (goto-char (point-at-bol)) ;; Emacs bug, move-to-column is wrong otherwise + (move-to-column start) + (setq beg-point (point)) + (when (> (current-column) start) + (goto-char (1- (point))) + (setq beg-point (point)) + (setq before-string (make-string (- start (current-column)) ? )))) + (move-to-column end) + (setq end-point (point)) + (let ((end-offset (- (current-column) end))) + (when (> end-offset 0) (setq after-string (make-string end-offset ?b)))) + (when no-insert + ;; prevent inheriting of faces + (setq before-string (when before-string (propertize before-string 'face 'default))) + (setq after-string (when after-string (propertize after-string 'face 'default)))) + (let ((string (concat before-string replacement after-string))) + (if no-insert + string + (push (dropdown-list-put-overlay beg-point end-point 'invisible t + 'after-string string) + dropdown-list-overlays))))) + +(defun dropdown-list-start-column (display-width) + (let ((column (mod (current-column) (window-width))) + (width (window-width))) + (cond ((<= (+ column display-width) width) column) + ((> column display-width) (- column display-width)) + ((>= width display-width) (- width display-width)) + (t nil)))) + +(defun dropdown-list-move-to-start-line (candidate-count) + (decf candidate-count) + (let ((above-line-count (save-excursion (- (vertical-motion (- candidate-count))))) + (below-line-count (save-excursion (vertical-motion candidate-count)))) + (cond ((= below-line-count candidate-count) + t) + ((= above-line-count candidate-count) + (vertical-motion (- candidate-count)) + t) + ((>= (+ below-line-count above-line-count) candidate-count) + (vertical-motion (- (- candidate-count below-line-count))) + t) + (t nil)))) + +(defun dropdown-list-at-point (candidates &optional selidx) + (dropdown-list-hide) + (let* ((lengths (mapcar #'length candidates)) + (max-length (apply #'max lengths)) + (start (dropdown-list-start-column (+ max-length 3))) + (i -1) + (candidates (mapcar* (lambda (candidate length) + (let ((diff (- max-length length))) + (propertize + (concat (if (> diff 0) + (concat candidate (make-string diff ? )) + (substring candidate 0 max-length)) + (format "%3d" (+ 2 i))) + 'face (if (eql (incf i) selidx) + 'dropdown-list-selection-face + 'dropdown-list-face)))) + candidates + lengths))) + (save-excursion + (and start + (dropdown-list-move-to-start-line (length candidates)) + (loop initially (vertical-motion 0) + for candidate in candidates + do (dropdown-list-line (+ (current-column) start) candidate) + while (/= (vertical-motion 1) 0) + finally return t))))) + +(defun dropdown-list (candidates) + (let ((selection) + (temp-buffer)) + (save-window-excursion + (unwind-protect + (let ((candidate-count (length candidates)) + done key (selidx 0)) + (while (not done) + (unless (dropdown-list-at-point candidates selidx) + (switch-to-buffer (setq temp-buffer (get-buffer-create "*selection*")) + 'norecord) + (delete-other-windows) + (delete-region (point-min) (point-max)) + (insert (make-string (length candidates) ?\n)) + (goto-char (point-min)) + (dropdown-list-at-point candidates selidx)) + (setq key (read-key-sequence "")) + (cond ((and (stringp key) + (>= (aref key 0) ?1) + (<= (aref key 0) (+ ?0 (min 9 candidate-count)))) + (setq selection (- (aref key 0) ?1) + done t)) + ((member key `(,(char-to-string ?\C-p) [up] "p")) + (setq selidx (mod (+ candidate-count (1- (or selidx 0))) + candidate-count))) + ((member key `(,(char-to-string ?\C-n) [down] "n")) + (setq selidx (mod (1+ (or selidx -1)) candidate-count))) + ((member key `(,(char-to-string ?\f)))) + ((member key `(,(char-to-string ?\r) [return])) + (setq selection selidx + done t)) + (t (setq done t))))) + (dropdown-list-hide) + (and temp-buffer (kill-buffer temp-buffer))) + ;; (when selection + ;; (message "your selection => %d: %s" selection (nth selection candidates)) + ;; (sit-for 1)) + selection))) + +(defun define-key* (keymap key command) + "Add COMMAND to the multiple-command binding of KEY in KEYMAP. +Use multiple times to bind different COMMANDs to the same KEY." + (define-key keymap key (combine-command command (lookup-key keymap key)))) + +(defun combine-command (command defs) + "$$$$$ FIXME - no doc string" + (cond ((null defs) command) + ((and (listp defs) + (eq 'lambda (car defs)) + (= (length defs) 4) + (listp (fourth defs)) + (eq 'command-selector (car (fourth defs)))) + (unless (member `',command (cdr (fourth defs))) + (setcdr (fourth defs) (nconc (cdr (fourth defs)) `(',command)))) + defs) + (t + `(lambda () (interactive) (command-selector ',defs ',command))))) + +(defvar command-selector-last-command nil "$$$$$ FIXME - no doc string") + +(defun command-selector (&rest candidates) + "$$$$$ FIXME - no doc string" + (if (and (eq last-command this-command) command-selector-last-command) + (call-interactively command-selector-last-command) + (let* ((candidate-strings + (mapcar (lambda (candidate) + (format "%s" (if (symbolp candidate) + candidate + (let ((s (format "%s" candidate))) + (if (>= (length s) 7) + (concat (substring s 0 7) "...") + s))))) + candidates)) + (selection (dropdown-list candidate-strings))) + (when selection + (let ((cmd (nth selection candidates))) + (call-interactively cmd) + (setq command-selector-last-command cmd)))))) + +;;;;;;;;;;;;;;;;;;;; + +(provide 'dropdown-list) + +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;; dropdown-list.el ends here;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +;;;; Auto-generated code ;;;; +;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; +(defun yas/initialize-bundle () + "Initialize YASnippet and load snippets in the bundle.";;; snippets for text-mode +(yas/define-snippets 'text-mode + '(("email" "`(replace-regexp-in-string \"@\" \"@NOSPAM.\" user-mail-address)`" "(user's email)" nil nil nil nil nil) + ("time" "`(current-time-string)`" "(current time)" nil nil nil nil nil)) + 'nil) + + +;;; snippets for cc-mode +(yas/define-snippets 'cc-mode + '(("do" "do\n{\n $0\n} while (${1:condition});" "do { ... } while (...)" nil nil nil nil nil) + ("for" "for (${1:int i = 0}; ${2:i < N}; ${3:++i})\n{\n $0\n}" "for (...; ...; ...) { ... }" nil nil nil nil nil) + ("if" "if (${1:condition})\n{\n $0\n}" "if (...) { ... }" nil nil nil nil nil) + ("inc" "#include \"$1\"\n" "#include \"...\"" nil nil nil nil nil) + ("inc" "#include <$1>\n" "#include <...>" nil nil nil nil nil) + ("main" "int main(int argc, char *argv[])\n{\n $0\n return 0;\n}\n" "int main(argc, argv) { ... }" nil nil nil nil nil) + ("once" "#ifndef ${1:_`(upcase (file-name-nondirectory (file-name-sans-extension (buffer-file-name))))`_H_}\n#define $1\n\n$0\n\n#endif /* $1 */" "#ifndef XXX; #define XXX; #endif" nil nil nil nil nil) + ("struct" "struct ${1:name}\n{\n $0\n};" "struct ... { ... }" nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for c++-mode +(yas/define-snippets 'c++-mode + '(("beginend" "${1:v}.begin(), $1.end" "v.begin(), v.end()" nil nil nil nil nil) + ("class" "class ${1:Name}\n{\npublic:\n ${1:$(yas/substr text \"[^: ]*\")}($2);\n virtual ~${1:$(yas/substr text \"[^: ]*\")}();\n};" "class ... { ... }" nil nil nil nil nil) + ("ns" "namespace " "namespace ..." nil nil nil nil nil) + ("template" "template " "template " nil nil nil nil nil) + ("using" "using namespace ${std};\n$0" "using namespace ... " nil nil nil nil nil)) + '(cc-mode)) + + +;;; snippets for c-mode +(yas/define-snippets 'c-mode + '(("fopen" "FILE *${fp} = fopen(${\"file\"}, \"${r}\");\n" "FILE *fp = fopen(..., ...);" nil nil nil nil nil) + ("printf" "printf (\"${1:%s}\\\\n\"${1:$(if (string-match \"%\" text) \",\" \"\\);\")\n}$2${1:$(if (string-match \"%\" text) \"\\);\" \"\")}" "printf " nil nil nil nil nil)) + '(cc-mode)) + + +;;; snippets for csharp-mode +(yas/define-snippets 'csharp-mode + '(("attrib" "/// \n/// $3\n/// \nprivate $1 $2;\n" "private attribute ....;" nil nil nil nil nil) + ("attrib" "/// \n/// $3\n/// \nprivate $1 $2;\n\n/// \n/// $4\n/// \n/// $5\npublic $1 $2\n{\n get {\n return this.$2;\n }\n set {\n this.$2 = value;\n }\n}\n" "private attribute ....; public property ... ... { ... }" nil nil nil nil nil) + ("attrib" "/// \n/// $3\n/// \nprivate $1 ${2:$(if (> (length text) 0) (format \"_%s%s\" (downcase (substring text 0 1)) (substring text 1 (length text))) \"\")};\n\n/// \n/// ${3:Description}\n/// \n/// $1\npublic ${1:Type} ${2:Name}\n{\n get {\n return this.${2:$(if (> (length text) 0) (format \"_%s%s\" (downcase (substring text 0 1)) (substring text 1 (length text))) \"\")};\n }\n set {\n this.${2:$(if (> (length text) 0) (format \"_%s%s\" (downcase (substring text 0 1)) (substring text 1 (length text))) \"\")} = value;\n }\n}\n" "private _attribute ....; public Property ... ... { ... }" nil nil nil nil nil) + ("class" "${5:public} class ${1:Name}\n{\n #region Ctor & Destructor\n /// \n /// ${3:Standard Constructor}\n /// \n public $1($2)\n {\n }\n\n /// \n /// ${4:Default Destructor}\n /// \n public ~$1()\n {\n }\n #endregion\n}\n" "class ... { ... }" nil nil nil nil nil) + ("comment" "/// \n/// $1\n/// \n" "/// ... " nil nil nil nil nil) + ("comment" "/// $2\n" "/// ... " nil nil nil nil nil) + ("comment" "/// $1\n" "/// ... " nil nil nil nil nil) + ("comment" "/// $2\n" "/// ... " nil nil nil nil nil) + ("method" "/// \n/// ${5:Description}\n/// ${2:$(if (string= (upcase text) \"VOID\") \"\" (format \"%s%s%s\" \"\\n/// \" text \"\"))}\n${1:public} ${2:void} ${3:MethodName}($4)\n{\n$0\n}\n" "public void Method { ... }" nil nil nil nil nil) + ("namespace" "namespace $1\n{\n$0\n}\n" "namespace .. { ... }" nil nil nil nil nil) + ("prop" "/// \n/// $5\n/// \n/// $6\n$1 $2 $3\n{\n get {\n return this.$4;\n }\n set {\n this.$4 = value;\n }\n}\n" "property ... ... { ... }" nil nil nil nil nil) + ("region" "#region $1\n$0\n#endregion\n" "#region ... #endregion" nil nil nil nil nil) + ("using" "using $1;\n" "using ...;" nil nil nil nil nil) + ("using" "using System;\n" "using System;" nil nil nil nil nil) + ("using" "using System.$1;\n" "using System....;" nil nil nil nil nil)) + '(cc-mode)) + + +;;; snippets for objc-mode +(yas/define-snippets 'objc-mode + '(("prop" "- (${1:id})${2:foo}\n{\n return $2;\n}\n\n- (void)set${2:$(capitalize text)}:($1)aValue\n{\n [$2 autorelease];\n $2 = [aValue retain];\n}\n$0" "foo { ... } ; setFoo { ... }" nil nil nil nil nil)) + '(cc-mode)) + + +;;; snippets for css-mode +(yas/define-snippets 'css-mode + '(("bg" "background-color: #${1:DDD};" "background-color: ..." nil nil nil nil nil) + ("bg" "background-image: url($1);" "background-image: ..." nil nil nil nil nil) + ("bor" "border: ${1:1px} ${2:solid} #${3:999};" "border size style color" nil nil nil nil nil) + ("cl" "clear: $1;\n" "clear: ..." nil nil nil nil nil) + ("disp" "display: block;\n" "display: block" nil nil nil nil nil) + ("disp" "display: inline;\n" "display: inline" nil nil nil nil nil) + ("disp" "display: none;\n" "display: none" nil nil nil nil nil) + ("ff" "font-family: $1;\n" "font-family: ..." nil nil nil nil nil) + ("fs" "font-size: ${12px};\n" "font-size: ..." nil nil nil nil nil) + ("mar" "margin-bottom: $1;\n" "margin-bottom: ..." nil nil nil nil nil) + ("mar" "margin-left: $1;\n" "margin-left: ..." nil nil nil nil nil) + ("mar" "margin: $1;\n" "margin: ..." nil nil nil nil nil) + ("mar" "margin: ${top} ${right} ${bottom} ${left};\n" "margin top right bottom left" nil nil nil nil nil) + ("mar" "margin-right: $1;\n" "margin-right: ..." nil nil nil nil nil) + ("mar" "margin-top: $1;\n" "margin-top: ..." nil nil nil nil nil) + ("pad" "padding-bottom: $1;\n" "padding-bottom: ..." nil nil nil nil nil) + ("pad" "padding-left: $1;\n" "padding-left: ..." nil nil nil nil nil) + ("pad" "padding: $1;\n" "padding: ..." nil nil nil nil nil) + ("pad" "padding: ${top} ${right} ${bottom} ${left};\n" "padding: top right bottom left" nil nil nil nil nil) + ("pad" "padding-right: $1;\n" "padding-right: ..." nil nil nil nil nil) + ("pad" "padding-top: $1;\n" "padding-top: ..." nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for emacs-lisp-mode +(yas/define-snippets 'emacs-lisp-mode + '(("defun" "(defun $1 ()\n \"thisandthat.\"\n (interactive)\n (let (var1)\n (setq var1 some)\n $0\n )\n)" "function template" nil nil nil nil nil) + ("dired" ";; idiom for processing a list of files in dired's marked files\n \n;; suppose myProcessFile is your function that takes a file path\n;; and do some processing on the file\n\n(defun dired-myProcessFile ()\n \"apply myProcessFile function to marked files in dired.\"\n (interactive)\n (require 'dired)\n (mapc 'myProcessFile (dired-get-marked-files))\n)\n\n;; to use it, type M-x dired-myProcessFile\n" "process marked files in dired" nil nil nil nil nil) + ("file" "(defun doThisFile (fpath)\n \"Process the file at path FPATH ...\"\n (let ()\n ;; create temp buffer without undo record or font lock. (more efficient)\n ;; first space in temp buff name is necessary\n (set-buffer (get-buffer-create \" myTemp\"))\n (insert-file-contents fpath nil nil nil t)\n\n ;; process it ...\n ;; (goto-char 0) ; move to begining of file's content (in case it was open)\n ;; ... do something here\n ;; (write-file fpath) ;; write back to the file\n\n (kill-buffer \" myTemp\")))\n" "a function that process a file" nil nil nil nil nil) + ("file" "(defun read-lines (filePath)\n \"Return a list of lines in FILEPATH.\"\n (with-temp-buffer\n (insert-file-contents filePath)\n (split-string\n (buffer-string) \"\\n\" t)) )\n\n;; process all lines\n(mapc \n (lambda (aLine) \n (message aLine) ; do your stuff here\n )\n (read-lines \"inputFilePath\")\n)" "read lines of a file" nil nil nil nil nil) + ("find-replace" "(defun replace-html-chars-region (start end)\n \"Replace < to < and other chars in HTML.\nThis works on the current region.\"\n (interactive \"r\")\n (save-restriction \n (narrow-to-region start end)\n (goto-char (point-min))\n (while (search-forward \"&\" nil t) (replace-match \"&\" nil t))\n (goto-char (point-min))\n (while (search-forward \"<\" nil t) (replace-match \"<\" nil t))\n (goto-char (point-min))\n (while (search-forward \">\" nil t) (replace-match \">\" nil t))\n )\n )\n" "find and replace on region" nil nil nil nil nil) + ("grabstring" "(setq $0 (buffer-substring-no-properties myStartPos myEndPos))\n" "grab buffer substring" nil nil nil nil nil) + ("grabthing" "(setq $0 (thing-at-point 'symbol))\n" "grab word under cursor" nil nil nil nil nil) + ("traverse_dir" ";; apply a function to all files in a dir\n(require 'find-lisp)\n(mapc 'my-process-file (find-lisp-find-files \"~/myweb/\" \"\\\\.html$\"))\n" "traversing a directory" nil nil nil nil nil) + ("word-or-region" ";; example of a command that works on current word or text selection\n(defun down-case-word-or-region ()\n \"Lower case the current word or text selection.\"\n(interactive)\n(let (pos1 pos2 meat)\n (if (and transient-mark-mode mark-active)\n (setq pos1 (region-beginning)\n pos2 (region-end))\n (setq pos1 (car (bounds-of-thing-at-point 'symbol))\n pos2 (cdr (bounds-of-thing-at-point 'symbol))))\n\n ; now, pos1 and pos2 are the starting and ending positions\n ; of the current word, or current text selection if exists\n\n ;; put your code here.\n $0\n ;; Some example of things you might want to do\n (downcase-region pos1 pos2) ; example of a func that takes region as args\n (setq meat (buffer-substring-no-properties pos1 pos2)) ; grab the text.\n (delete-region pos1 pos2) ; get rid of it\n (insert \"newText\") ; insert your new text\n\n )\n)\n" "Command that works on region or word" nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for erlang-mode +(yas/define-snippets 'erlang-mode + '(("after" "after\n $1 -> $0\n" "after ... ->" nil nil nil nil nil) + ("begin" "begin\n $0\nend\n" "begin ... end" nil nil nil nil nil) + ("beh" "-behaviour(${1:gen_server}).\n$0\n" "-behaviour(...)." nil nil nil nil nil) + ("case" "case $1 of\n $0\nend\n" "case ... of ... end" nil nil nil nil nil) + ("compile" "-compile([${1:export_all}]).\n$0\n" "-compile(...)." nil nil nil nil nil) + ("def" "-define($1,$2).\n$0\n" "-define(...,...)." nil nil nil nil nil) + ("exp" "-export([${1:start/0}]).\n$0\n" "-export([])." nil nil nil nil nil) + ("fun" "fun ($1) -> $0 end\n" "fun (...) -> ... end" nil nil nil nil nil) + ("if" "if\n $1 -> $2;\n true -> $0\nend\n" "if ... -> ... ; true -> ... end" nil nil nil nil nil) + ("ifdef" "-ifdef($1).\n$0\n-endif.\n" "-ifdef(...). ... -endif." nil nil nil nil nil) + ("ifndef" "-ifndef($1).\n$0\n-endif.\n" "-ifndef(...). ... -endif." nil nil nil nil nil) + ("imp" "-import(${1:lists}, [${2:map/2, sum/1}]).\n$0\n" "-import([])." nil nil nil nil nil) + ("inc" "-include(\"$1\").\n$0\n" "-include(\"...\")." nil nil nil nil nil) + ("inc" "-include_lib(\"$1\").\n$0\n" "-include_lib(\"...\")." nil nil nil nil nil) + ("loop" "${1:loop}($2) ->\n receive\n ${3:_} ->\n $1($2)\n end.\n$0\n" "loop(...) -> receive _ -> loop(...) end." nil nil nil nil nil) + ("mod" "-module(${1:`(file-name-nondirectory\n (file-name-sans-extension (or (buffer-file-name) (buffer-name))))`}).\n$0\n" "-module()." nil nil nil nil nil) + ("rcv" "receive\n $1 -> $0\nend\n" "receive ... -> ... end" nil nil nil nil nil) + ("rcv" "receive\nafter\n $1 -> $0\nend\n" "receive after ... -> ... end" nil nil nil nil nil) + ("rec" "-record($1,{$2}).\n$0\n" "-record(...,{...})." nil nil nil nil nil) + ("try" "try $1 of\n $0\ncatch\nafter\nend\n" "try ... of ... catch after end" nil nil nil nil nil) + ("undef" "-undef($1).\n$0\n" "-undef(...)." nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for f90-mode +(yas/define-snippets 'f90-mode + '(("au" "automatic $0 \n" "automatic" nil nil nil nil nil) + ("bd" "block data $0\n" "block data" nil nil nil nil nil) + ("c" "continue $0\n" "continue" nil nil nil nil nil) + ("ch" "character $0\n" "character" nil nil nil nil nil) + ("cx" "complex $0\n" "complex" nil nil nil nil nil) + ("dc" "double complex $0\n" "double complex" nil nil nil nil nil) + ("do" "do while (${1:condition})\n $0\nend do\n" "do while (...) end do" nil nil nil nil nil) + ("dp" "double precision $0\n" "double precision" nil nil nil nil nil) + ("eq" "equivalence $0\n" "equivalence" nil nil nil nil nil) + ("ib" "implicit byte $0\n" "implicit byte" nil nil nil nil nil) + ("ic" "implicit complex $0\n" "implicit complex" nil nil nil nil nil) + ("ich" "implicit character $0\n" "implicit character" nil nil nil nil nil) + ("if" "if ( ${1:condition} ) then\n $0\nend if\n" "if then end if" nil nil nil nil nil) + ("ii" "implicit integer $0\n" "implicit integer " nil nil nil nil nil) + ("il" "implicit logical $0\n" "implicit logical" nil nil nil nil nil) + ("in" "implicit none\n" "implicit none" nil nil nil nil nil) + ("inc" "include $0\n" "include" nil nil nil nil nil) + ("intr" "intrinsic $0\n" "intrinsic" nil nil nil nil nil) + ("ir" "implicit real $0\n" "implicit real" nil nil nil nil nil) + ("l" "logical $0\n" "logical" nil nil nil nil nil) + ("pa" "parameter $0\n" "parameter" nil nil nil nil nil) + ("pr" "program ${1:name}\n $0\nend program ${1:name}\n" "program ... end program ..." nil nil nil nil nil) + ("re" "read (${1:*},${2:*}) $0\n" "read (*,*)" nil nil nil nil nil) + ("st" "structure $0\n" "structure" nil nil nil nil nil) + ("su" "subroutine $0\n" "subroutine" nil nil nil nil nil) + ("wr" "write (${1:*},${2:*}) $0\n" "write (*,*)" nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for html-mode +(yas/define-snippets 'html-mode + '(("body" "\n $0\n" "..." nil nil nil nil nil) + ("br" "
" "
" nil nil nil nil nil) + ("code" "\n $0\n" "..." nil nil nil nil nil) + ("code" "\n $0\n" "..." nil nil nil nil nil) + ("dd" "
$1
" "
...
" nil "list" nil nil nil) + ("div" "$0 " "..." nil nil nil nil nil) + ("div" "
\n $0\n
" "
...
" nil nil nil nil nil) + ("div" "
\n $0\n
" "
...
" nil nil nil nil nil) + ("div" "
\n $0\n
" "
...
" nil nil nil nil nil) + ("dl" "
\n $0\n
\n" "
...
" nil "list" nil nil nil) + ("dl" "
\n $0\n
" "
...
" nil "list" nil nil nil) + ("doctype" "" "Doctype HTML 4.01 Strict" nil "meta" nil nil nil) + ("doctype" "" "DocType XHTML 1.0 frameset" nil "meta" nil nil nil) + ("doctype" "" "DocType XHTML 1.1" nil "meta" nil nil nil) + ("doctype" "" "DocType XHTML 1.0 Strict" nil "meta" nil nil nil) + ("doctype" "" "DocType XHTML 1.0 Transitional" nil "meta" nil nil nil) + ("dov" "a mirror up here $3\n\n\n\n $0\n\n\n actually some other shit and $3\n\n" "..." nil nil nil nil nil) + ("dt" "
$1
" "
...
" nil "list" nil nil nil) + ("form" "
\n $0\n
" "
" nil nil nil nil nil) + ("h1" "

$1

" "

...

" nil "header" nil nil nil) + ("h2" "

$1

" "

...

" nil "header" nil nil nil) + ("h3" "

$1

" "

...

" nil "header" nil nil nil) + ("h4" "

$1

" "

...

" nil "header" nil nil nil) + ("h5" "
$1
" "
...
" nil "header" nil nil nil) + ("h6" "
$1
" "
...
" nil "header" nil nil nil) + ("head" "\n $0\n" "..." nil nil nil nil nil) + ("hr" "
\n" "
" nil nil nil nil nil) + ("href" "$2" "..." nil nil nil nil nil) + ("html" "\n $0\n\n" "..." nil nil nil nil nil) + ("html" "\n $0\n\n" "..." nil nil nil nil nil) + ("img" "\"$3\"" "\"...\"" nil nil nil nil nil) + ("input" "" "" nil nil nil nil nil) + ("li" "
  • $1
    • " "
  • ...
    • " nil "list" nil nil nil) + ("li" "
  • $2
    • " "
  • ...
    • " nil "list" nil nil nil) + ("link" "" "" nil nil nil nil nil) + ("link" "" "" nil nil nil nil nil) + ("mailto" "$0" "..." nil nil nil nil nil) + ("meta" "" "" nil "meta" nil nil nil) + ("meta" "" "" nil "meta" nil nil nil) + ("ol" "
      \n $0\n
    " "
      ...
    " nil "list" nil nil nil) + ("ol" "
      \n $0\n
    " "
      ...
    " nil "list" nil nil nil) + ("ol" "
      \n $0\n
    " "
      ...
    " nil "list" nil nil nil) + ("p" "

    $1

    " "

    ...

    " nil nil nil nil nil) + ("pre" "
    \n  $0\n
    " "
    ...
    " nil nil nil nil nil) + ("quote" "
    \n $1\n
    " "
    ...
    " nil nil nil nil nil) + ("script" "" " " nil nil nil nil nil) + ("script" "" " " nil nil nil nil nil) + ("span" "$1" "..." nil nil nil nil nil) + ("span" "$2" "..." nil nil nil nil nil) + ("span" "$2" "..." nil nil nil nil nil) + ("style" "" "" nil nil nil nil nil) + ("table" "\n $0\n
    " "...
    " nil "table" nil nil nil) + ("td" "$2" "..." nil "table" nil nil nil) + ("textarea" "" "" nil nil nil nil nil) + ("th" "$2" "..." nil "table" nil nil nil) + ("title" "$1" "..." nil nil nil nil nil) + ("tr" "\n $0\n" "..." nil "table" nil nil nil) + ("ul" "
      \n $0\n
    " "
      ...
    " nil "list" nil nil nil) + ("ul" "
      \n $0\n
    " "
      ...
    " nil "list" nil nil nil) + ("ul" "
      \n $0\n
    " "
      ...
    " nil "list" nil nil nil)) + '(text-mode)) + + +;;; snippets for latex-mode +(yas/define-snippets 'latex-mode + '(("begin" "\n\\begin{${1:environment}}\n$0\n\\end{$1}\n" "\\begin{environment} ... \\end{environment}" nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for markdown-mode +(yas/define-snippets 'markdown-mode + '(("+" "+ ${1:Text}\n+$0\n" "Unordered List" nil nil nil nil nil) + ("-" "- ${1:Text}\n-$0\n" "Unordered List" nil nil nil nil nil) + ("_" "_${1:Text}_ $0\n" "Emphasis" nil nil nil nil nil) + ("__" "**${1:Text}** $0\n" "Strong" nil nil nil nil nil) + ("`" "\\`${1:Code}\\` $0\n" "Inline Code" nil nil nil nil nil) + ("h1" "# ${1:Header 1} #\n\n$0\n" "Header 1 (#)" nil nil nil nil nil) + ("h1" "${1:Header 1}\n${1:$(make-string (string-width text) ?\\=)}\n\n$0\n" "Header 1 (=)" nil nil nil nil nil) + ("h2" "## ${1:Header 1} ##\n\n$0\n" "Header 2 (##)" nil nil nil nil nil) + ("h2" "${1:Header 2}\n${1:$(make-string (string-width text) ?\\-)}\n\n$0\n" "Header 2 (-)" nil nil nil nil nil) + ("h3" "### ${1:Header 3} ###\n\n$0\n" "Header 3" nil nil nil nil nil) + ("h4" "#### ${1:Header 4} ####\n\n$0\n" "Header 4" nil nil nil nil nil) + ("h5" "##### ${1:Header 5} #####\n\n$0\n" "Header 5" nil nil nil nil nil) + ("h6" "###### ${1:Header 6} ######\n\n$0\n" "Header 6" nil nil nil nil nil) + ("hr" "\n----------\n\n$0\n" "Horizontal Rule (-)" nil nil nil nil nil) + ("hr" "\n*******\n\n$0\n" "Horizontal Rule (*)" nil nil nil nil nil) + ("img" "![${1:Alt Text}](${2:URL} $3) $0\n" "Image" nil nil nil nil nil) + ("link" "[${1:Link Text}](${2:URL} $3) $0\n" "Link" nil nil nil nil nil) + ("ol" "${1:1}. ${2:Text}\n${1:$(number-to-string (1+ (string-to-number text)))}. $0\n" "Ordered List" nil nil nil nil nil) + ("rimg" "![${1:Alt Text}][$2] $0\n" "Referenced Image" nil nil nil nil nil) + ("rlb" "[${1:Reference}]: ${2:URL} $3\n$0\n" "Reference Label" nil nil nil nil nil) + ("rlink" "[${1:Link Text}][$2] $0\n" "Reference Link" nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for nxml-mode +(yas/define-snippets 'nxml-mode + '(("body" "\n $0\n" "..." nil nil nil nil nil) + ("br" "
    " "
    " nil nil nil nil nil) + ("code" "\n $0\n" "..." nil nil nil nil nil) + ("div" "$0" "..." nil nil nil nil nil) + ("doctype" "" "DocType XHTML 1.1" nil "meta" nil nil nil) + ("doctype" "" "DocType XHTML 1.0 Strict" nil "meta" nil nil nil) + ("doctype" "" "DocType XHTML 1.0 Transitional" nil "meta" nil nil nil) + ("form" "
    \n $0\n
    " "
    " nil nil nil nil nil) + ("h1" "

    $1

    " "

    ...

    " nil "header" nil nil nil) + ("h2" "

    $1

    " "

    ...

    " nil "header" nil nil nil) + ("h3" "

    $1

    " "

    ...

    " nil "header" nil nil nil) + ("h4" "

    $1

    " "

    ...

    " nil "header" nil nil nil) + ("h5" "
    $1
    " "
    ...
    " nil "header" nil nil nil) + ("h6" "
    $1
    " "
    ...
    " nil "header" nil nil nil) + ("head" "\n $0\n" "..." nil nil nil nil nil) + ("hr" "
    \n" "
    " nil nil nil nil nil) + ("href" "$2" "..." nil nil nil nil nil) + ("html" "\n $0\n\n" "..." nil nil nil nil nil) + ("img" "\"$2\"" "\"...\"" nil nil nil nil nil) + ("input" "" "" nil nil nil nil nil) + ("li" "
  • $1
    • " "
  • ...
    • " nil nil nil nil nil) + ("link" "" "" nil nil nil nil nil) + ("meta" "" "" nil "meta" nil nil nil) + ("name" "" "" nil nil nil nil nil) + ("ol" "
      \n $0\n
    " "
      ...
    " nil nil nil nil nil) + ("p" "

    $1

    " "

    ...

    " nil nil nil nil nil) + ("pre" "
    \n  $0\n
    " "
    ...
    " nil nil nil nil nil) + ("quote" "
    \n $1\n
    " "
    ...
    " nil nil nil nil nil) + ("span" "$1" "..." nil nil nil nil nil) + ("style" "" "" nil nil nil nil nil) + ("table" "\n $0\n
    " "...
    " nil nil nil nil nil) + ("tag" "<${1:tag}>$2$0" "..." nil nil nil nil nil) + ("tag" "<${1:tag}>\n $2\n$0" " \\n...\\n" nil nil nil nil nil) + ("td" "$2" "..." nil nil nil nil nil) + ("th" "$2" "..." nil nil nil nil nil) + ("title" "$1" "..." nil nil nil nil nil) + ("tr" "\n $0\n" "..." nil nil nil nil nil) + ("ul" "
      \n $0\n
    " "
      ...
    " nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for perl-mode +(yas/define-snippets 'perl-mode + '(("eval" "eval {\n ${1:# do something risky...}\n};\nif (\\$@) {\n ${2:# handle failure...}\n}" "eval { ... } if ($@) { ... }" nil nil nil nil nil) + ("for" "for (my \\$${1:var} = 0; \\$$1 < ${2:expression}; \\$$1++) {\n ${3:# body...}\n}" "for (...) { ... }" nil nil nil nil nil) + ("fore" "foreach my \\$${1:x} (@${2:array}) {\n ${3:# body...}\n}" "foreach ... { ... }" nil nil nil nil nil) + ("if" "if ($1) {\n $0\n}" "if (...) { ... }" nil nil nil nil nil) + ("ife" "if ($1) {\n $2\n} else {\n $3\n}" "if (...) { ... } else { ... }" nil nil nil nil nil) + ("ifee" "if ($1) {\n ${2:# body...}\n} elsif ($3) {\n ${4:# elsif...}\n} else {\n ${5:# else...}\n}" "if, elsif, else ..." nil nil nil nil nil) + ("sub" "sub ${1:function_name} {\n $0\n}" "sub ... { ... }" nil nil nil nil nil) + ("unless" "unless ($1) {\n $0\n}" "unless (...) { ... }" nil nil nil nil nil) + ("while" "while ($1) {\n $0\n}" "while (...) { ... }" nil nil nil nil nil) + ("xfore" "${1:expression} foreach @${2:array};" "... foreach ..." nil nil nil nil nil) + ("xif" "${1:expression} if ${2:condition}" "... if ..." nil nil nil nil nil) + ("xunless" "${1:expression} unless ${2:condition}" "... unless ..." nil nil nil nil nil) + ("xwhile" "${1:expression} while ${2:condition};" "... while ..." nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for cperl-mode +(yas/define-snippets 'cperl-mode 'nil + '(perl-mode)) + + +;;; snippets for python-mode +(yas/define-snippets 'python-mode + '(("__" "__${init}__" "__...__" nil nil nil nil nil) + ("class" "class ${1:ClassName}(${2:object}):\n \"\"\"$3\n \"\"\"\n\n def __init__(self, $4):\n \"\"\"$5\n ${4:$\n (let* ((indent\n (concat \"\\n\" (make-string (current-column) 32)))\n (args\n (mapconcat\n '(lambda (x)\n (if (not (string= (nth 0 x) \"\"))\n (concat \"- \" (char-to-string 96) (nth 0 x)\n (char-to-string 96) \":\")))\n (mapcar\n '(lambda (x)\n (mapcar\n (lambda (x)\n (replace-regexp-in-string \"[[:blank:]]*$\" \"\"\n (replace-regexp-in-string \"^[[:blank:]]*\" \"\" x))) x))\n (mapcar '(lambda (x) (split-string x \"=\"))\n (split-string text \",\")))\n indent)))\n (if (string= args \"\")\n (make-string 3 34)\n (mapconcat\n 'identity\n (list \"\" \"Arguments:\" args (make-string 3 34))\n indent)))\n }\n ${4:$\n (mapconcat\n '(lambda (x)\n (if (not (string= (nth 0 x) \"\"))\n (concat \"self._\" (nth 0 x) \" = \" (nth 0 x))))\n (mapcar\n '(lambda (x)\n (mapcar\n '(lambda (x)\n (replace-regexp-in-string \"[[:blank:]]*$\" \"\"\n (replace-regexp-in-string \"^[[:blank:]]*\" \"\" x)))\n x))\n (mapcar '(lambda (x) (split-string x \"=\"))\n (split-string text \",\")))\n (concat \"\\n\" (make-string (current-column) 32)))\n }\n $0\n" "class" nil nil nil nil nil) + ("def" "def ${1:name}($2):\n \"\"\"$3\n ${2:$\n (let* \n ((indent\n (concat \"\\n\" (make-string (current-column) 32)))\n (args\n (mapconcat\n '(lambda (x)\n (if (not (string= (nth 0 x) \"\"))\n (concat \"- \" (char-to-string 96) (nth 0 x)\n (char-to-string 96) \":\")))\n (mapcar\n '(lambda (x)\n (mapcar\n '(lambda (x)\n (replace-regexp-in-string \"[[:blank:]]*$\" \"\"\n (replace-regexp-in-string \"^[[:blank:]]*\" \"\" x)))\n x))\n (mapcar '(lambda (x) (split-string x \"=\"))\n (split-string text \",\")))\n indent)))\n (if (string= args \"\")\n (make-string 3 34)\n (mapconcat\n 'identity\n (list \"\" \"Arguments:\" args (make-string 3 34))\n indent)))\n }\n $0\n" "def" nil nil nil nil nil) + ("defm" "def ${1:name}(self, $2):\n \"\"\"$3\n ${2:$\n (let* ((indent\n (concat \"\\n\" (make-string (current-column) 32)))\n (args\n (mapconcat\n '(lambda (x)\n (if (not (string= (nth 0 x) \"\"))\n (concat \"- \" (char-to-string 96) (nth 0 x)\n (char-to-string 96) \":\")))\n (mapcar\n '(lambda (x)\n (mapcar\n '(lambda (x)\n (replace-regexp-in-string \"[[:blank:]]*$\" \"\"\n (replace-regexp-in-string \"^[[:blank:]]*\" \"\" x)))\n x))\n (mapcar '(lambda (x) (split-string x \"=\"))\n (split-string text \",\")))\n indent)))\n (if (string= args \"\")\n (make-string 3 34)\n (mapconcat\n 'identity\n (list \"\" \"Arguments:\" args (make-string 3 34))\n indent)))\n }\n $0\n" "defm" nil nil nil nil nil) + ("for" "for ${var} in ${collection}:\n $0" "for ... in ... : ..." nil nil nil nil nil) + ("ifmain" "if __name__ == '__main__':\n $0" "if __name__ == '__main__': ..." nil nil nil nil nil) + ("prop" "def ${1:foo}():\n doc = \"\"\"${2:Doc string}\"\"\"\n def fget(self):\n return self._$1\n def fset(self, value):\n self._$1 = value\n def fdel(self):\n del self._$1\n return locals()\n$1 = property(**$1())\n\n$0\n" "prop" nil nil nil nil nil) + ("propg" "def _get_${1:foo}(self):\n return self._$1\n\n$1 = property(_get_$1)\n\n$0\n" "_get_foo ... foo=property(...)" nil nil nil nil nil) + ("propsg" "def _set_${1:foo}(self, value):\n self._$1 = value\n\ndef _get_$1(self):\n return self._$1\n\n$1 = property(_get_$1, _set_$1)\n\n$0\n" "_get_foo ... _set_foo ... foo=property(...)" nil nil nil nil nil) + ("while" "while ${condition}:\n $0" "while ... : ..." nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for rst-mode +(yas/define-snippets 'rst-mode + '(("chap" "${1:Chapter}\n${1:$(make-string (string-width text) ?\\=)}\n\n$0" "Chapter title" nil nil nil nil nil) + ("sec" "${1:Section}\n${1:$(make-string (string-width text) ?\\-)}\n\n$0" "Section title" nil nil nil nil nil) + ("tit" "${1:$(make-string (string-width text) ?\\=)}\n${1:Title}\n${1:$(make-string (string-width text) ?\\=)}\n\n$0" "Document title" nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for ruby-mode +(yas/define-snippets 'ruby-mode + '(("#" "# => " "# =>" nil "general" nil nil nil) + ("=b" "=begin rdoc\n $0\n=end" "=begin rdoc ... =end" nil "general" nil nil nil) + ("Comp" "include Comparable\n\ndef <=> other\n $0\nend" "include Comparable; def <=> ... end" nil "definitions" nil nil nil) + ("all" "all? { |${e}| $0 }" "all? { |...| ... }" nil "collections" nil nil nil) + ("am" "alias_method :${new_name}, :${old_name}" "alias_method new, old" nil "definitions" nil nil nil) + ("any" "any? { |${e}| $0 }" "any? { |...| ... }" nil "collections" nil nil nil) + ("app" "if __FILE__ == $PROGRAM_NAME\n $0\nend" "if __FILE__ == $PROGRAM_NAME ... end" nil "general" nil nil nil) + ("bm" "Benchmark.bmbm(${1:10}) do |x|\n $0\nend" "Benchmark.bmbm(...) do ... end" nil "general" nil nil nil) + ("case" "case ${1:object}\nwhen ${2:condition}\n $0\nend" "case ... end" nil "general" nil nil nil) + ("cla" "class << ${self}\n $0\nend" "class << self ... end" nil "definitions" nil nil nil) + ("classify" "classify { |${e}| $0 }" "classify { |...| ... }" nil "collections" nil nil nil) + ("cls" "class ${1:`(let ((fn (capitalize (file-name-nondirectory\n (file-name-sans-extension\n (or (buffer-file-name)\n (buffer-name (current-buffer))))))))\n (cond\n ((string-match \"_\" fn) (replace-match \"\" nil nil fn))\n (t fn)))`}\n $0\nend\n" "class ... end" nil "definitions" nil nil nil) + ("collect" "collect { |${e}| $0 }" "collect { |...| ... }" nil "collections" nil nil nil) + ("dee" "Marshal.load(Marshal.dump($0))" "deep_copy(...)" nil "general" nil nil nil) + ("deli" "delete_if { |${e} $0 }" "delete_if { |...| ... }" nil "collections" nil nil nil) + ("det" "detect { |${e}| $0 }" "detect { |...| ... }" nil "collections" nil nil nil) + ("dow" "downto(${0}) { |${n}|\n $0\n}" "downto(...) { |n| ... }" nil "control structure" nil nil nil) + ("ea" "each { |${e}| $0 }" "each { |...| ... }" nil "collections" nil nil nil) + ("eac" "each_cons(${1:2}) { |${group}| $0 }" "each_cons(...) { |...| ... }" nil "collections" nil nil nil) + ("eai" "each_index { |${i}| $0 }" "each_index { |i| ... }" nil "collections" nil nil nil) + ("eav" "each_value { |${val}| $0 }" "each_value { |val| ... }" nil "collections" nil nil nil) + ("eawi" "each_with_index { |${e}, ${i}| $0 }" "each_with_index { |e, i| ... }" nil "collections" nil nil nil) + ("forin" "for ${1:element} in ${2:collection}\n $0\nend" "for ... in ...; ... end" nil "control structure" nil nil nil) + ("if" "if ${1:condition}\n $0\nend" "if ... end" nil "control structure" nil nil nil) + ("ife" "if ${1:condition}\n $2\nelse\n $3\nend" "if ... else ... end" nil "control structure" nil nil nil) + ("inject" "inject(${1:0}) { |${2:injection}, ${3:element}| $0 }" "inject(...) { |...| ... }" nil "collections" nil nil nil) + ("mm" "def method_missing(method, *args)\n $0\nend" "def method_missing ... end" nil "definitions" nil nil nil) + ("r" "attr_reader :" "attr_reader ..." nil "definitions" nil nil nil) + ("rb" "#!/usr/bin/ruby -wKU\n" "/usr/bin/ruby -wKU" nil "general" nil nil nil) + ("reject" "reject { |${1:element}| $0 }" "reject { |...| ... }" nil "collections" nil nil nil) + ("req" "require \"$0\"" "require \"...\"" nil "general" nil nil nil) + ("rreq" "require File.join(File.dirname(__FILE__), $0)" "require File.join(File.dirname(__FILE__), ...)" nil "general" nil nil nil) + ("rw" "attr_accessor :" "attr_accessor ..." nil "definitions" nil nil nil) + ("select" "select { |${1:element}| $0 }" "select { |...| ... }" nil "collections" nil nil nil) + ("tim" "times { |${n}| $0 }" "times { |n| ... }" nil "control structure" nil nil nil) + ("until" "until ${condition}\n $0\nend" "until ... end" nil "control structure" nil nil nil) + ("upt" "upto(${n}) { |${i}|\n $0\n}" "upto(...) { |n| ... }" nil "control structure" nil nil nil) + ("w" "attr_writer :" "attr_writer ..." nil "definitions" nil nil nil) + ("when" "when ${condition}\n $0\nend" "when ... end" nil "control structure" nil nil nil) + ("while" "while ${condition}\n $0\nend" "while ... end" nil "control structure" nil nil nil) + ("y" ":yields: $0" ":yields: arguments (rdoc)" nil "general" nil nil nil) + ("zip" "zip(${enums}) { |${row}| $0 }" "zip(...) { |...| ... }" nil "collections" nil nil nil)) + '(text-mode)) + + +;;; snippets for scala-mode +(yas/define-snippets 'scala-mode + '(("act" "def act = {\n loop {\n react {\n $0\n }\n }\n}" "def act = { ..}" nil nil nil nil nil) + ("act" "def act(${1:arg}: ${2:type}) = {\n loop {\n react {\n $0\n }\n }\n}" "def act(arg: T) = { ..}" nil nil nil nil nil) + ("actor" "val a = actor {\n loop {\n react {\n $0\n }\n }\n}" "val a = actor { ..}" nil nil nil nil nil) + ("ano" "($1) => ${2:body} $0" "(args) => ..." nil nil nil nil nil) + ("app" "object ${1:name} extends Application {\n $0\n}" "object name extends Application" nil nil nil nil nil) + ("arr" "Array[${1:value}](${2:args}) $0" "Array[T](..)" nil nil nil nil nil) + ("arr" "val ${1:arr} = Array[${2:value}](${3:args}) $0" "val a = Array[T](..)" nil nil nil nil nil) + ("asof" "asInstanceOf[${1:type}] $0" "asInstanceOf[T] " nil nil nil nil nil) + ("ass" "assert(${1:x} === ${2:y}) $0" "assert(x === y)" nil nil nil nil nil) + ("ass" "assert(true) $0" "assert(true)" nil nil nil nil nil) + ("at" "@author ${1:name} $0" "@author name" nil nil nil nil nil) + ("at" "@param ${1:name} ${2:description} $0" "@param name description" nil nil nil nil nil) + ("at" "@return ${1:description} $0" "@return description" nil nil nil nil nil) + ("at" "@version ${1:0.1} $0" "@version number" nil nil nil nil nil) + ("bang" "${1:actor} ! ${2:message} $0" "actor ! message" nil nil nil nil nil) + ("case" "case ${1:pattern} => $0" "case pattern => " nil nil nil nil nil) + ("case" "case _ => $0" "case _ => " nil nil nil nil nil) + ("cast" "asInstanceOf[${1:type}] $0" "asInstanceOf[T] " nil nil nil nil nil) + ("cc" "case class ${1:name}(${2:arg}: ${3:type}) $0" "case class T(arg: A)" nil nil nil nil nil) + ("cl" "class ${1:name} {\n $0\n}" "class T { .. }" nil nil nil nil nil) + ("cl" "abstract class ${1:name} {\n $0\n}" "abstract class T { .. }" nil nil nil nil nil) + ("cl" "abstract class ${1:name}(${2:args}) {\n $0\n}" "abstract class T(args) { .. }" nil nil nil nil nil) + ("cl" "class ${1:name}(${2:args}) {\n $0\n}" "class T(args) { .. }" nil nil nil nil nil) + ("clof" "classOf[${1:type}] $0" "classOf[T] " nil nil nil nil nil) + ("co" "case object ${1:name} $0" "case object T" nil nil nil nil nil) + ("cons" "${1:element1} :: ${2:element2} $0" "element1 :: element2" nil nil nil nil nil) + ("cons" "${1:element1} :: Nil $0\n" "element1 :: Nil" nil nil nil nil nil) + ("def" "def ${1:name}(${2:args}) = $0" "def f(arg: T) = ..." nil nil nil nil nil) + ("def" "def ${1:name}(${2:args}) = {\n $0\n}" "def f(arg: T) = {...}" nil nil nil nil nil) + ("def" "def ${1:name}(${2:args}): ${3:Unit} = $0" "def f(arg: T): R = ..." nil nil nil nil nil) + ("def" "def ${1:name}(${2:args}): ${3:Unit} = {\n $0\n}" "def f(arg: T): R = {...}" nil nil nil nil nil) + ("def" "def ${1:name} = {\n $0\n}" "def f = {...}" nil nil nil nil nil) + ("def" "def ${1:name}: ${2:Unit} = $0" "def f: R = ..." nil nil nil nil nil) + ("def" "def ${1:name}: ${3:Unit} = {\n $0\n}" "def f: R = {...}" nil nil nil nil nil) + ("def" "def ${1:name} = $0" "def f = ..." nil nil nil nil nil) + ("doc" "/** \n * `(scala-mode-find-clstrtobj-name-doc)`\n * ${1:description}\n * $0 \n */" "/** cls/trt/obj name */" nil nil nil nil nil) + ("doc" "/** \n * `(scala-mode-def-and-args-doc)`\n */ " "/** method name */" nil nil nil nil nil) + ("doc" "/**\n * `(scala-mode-file-doc)`\n * $0\n * @author ${1:name}\n * @version ${2:0.1} \n */" "/** file name */" nil nil nil nil nil) + ("doc" "/* __ *\\\n** ________ ___ / / ___ Scala $3 **\n** / __/ __// _ | / / / _ | (c) 2005-`(format-time-string \"%Y\")` , LAMP/EPFL **\n** __\\ \\/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **\n** /____/\\___/_/ |_/____/_/ | | **\n** |/ **\n\\* */\n/** \n * $0\n * @author ${1:name} \n * @version ${2:0.1}\n * $Id$\n */" "/** scala file */" nil nil nil nil nil) + ("doc" "/* __ *\\\n** ________ ___ / / ___ Scala API **\n** / __/ __// _ | / / / _ | (c) 2005-`(format-time-string \"%Y\")`, LAMP/EPFL **\n** __\\ \\/ /__/ __ |/ /__/ __ | http://scala-lang.org/ **\n** /____/\\___/_/ |_/____/_/ | | **\n** |/ **\n\\* */\n/** \n * $0\n * @author ${1:name} \n * @version ${2:0.1}\n * $Id$\n */" "/** scala api file */" nil nil nil nil nil) + ("doc" "/**\n * ${1:description}\n * $0\n */" "/** ... */" nil nil nil nil nil) + ("expect" "expect(${1:reply}) {\n $0\n}" "expect(value) { ..}" nil nil nil nil nil) + ("ext" "extends $0" "extends T" nil nil nil nil nil) + ("for" "${1:x} <- ${2:xs}" "x <- xs" nil nil nil nil nil) + ("for" "for (${1:x} <- ${2:xs} if ${3:guard}) {\n $0\n}" "for (x <- xs if guard) { ... }" nil nil nil nil nil) + ("for" "for (${1:x} <- ${2:xs}) {\n $0\n}" "for (x <- xs) { ... }" nil nil nil nil nil) + ("for" "for {\n ${1:x} <- ${2:xs}\n ${3:x} <- ${4:xs}\n} {\n yield $0\n}" "for {x <- xs \\ y <- ys} { yield }" nil nil nil nil nil) + ("foreach" "foreach(${1:x} => ${2:body}) $0" "foreach(x => ..)" nil nil nil nil nil) + ("hmap" "new HashMap[${1:key}, ${2:value}] $0" "new HashMap[K, V]" nil nil nil nil nil) + ("hmap" "val ${1:m} = new HashMap[${2:key}, ${3:value}] $0" "val m = new HashMap[K, V]" nil nil nil nil nil) + ("hset" "new HashSet[${1:key}] $0\n" "new HashSet[K]" nil nil nil nil nil) + ("hset" "val ${1:m} = new HashSet[${2:key}] $0" "val m = new HashSet[K]" nil nil nil nil nil) + ("if" "if (${1:condition}) {\n $0\n}" "if (cond) { .. }" nil nil nil nil nil) + ("if" "if (${1:condition}) {\n $2\n} else {\n $0\n}" "if (cond) { .. } else { .. }" nil nil nil nil nil) + ("imp" "import $0" "import .." nil nil nil nil nil) + ("intercept" "intercept(classOf[${1:Exception]}) {\n $0\n}" "intercept(classOf[T]) { ..}" nil nil nil nil nil) + ("isof" "isInstanceOf[${1:type}] $0" "isInstanceOf[T] " nil nil nil nil nil) + ("ls" "List(${1:args}, ${2:args}) $0" "List(..)" nil nil nil nil nil) + ("ls" "val ${1:l} = List(${2:args}, ${3:args}) $0" "val l = List(..)" nil nil nil nil nil) + ("main" "def main(args: Array[String]) = {\n $0\n}" "def main(args: Array[String]) = { ... }" nil nil nil nil nil) + ("map" "map(${1:x} => ${2:body}) $0" "map(x => ..)" nil nil nil nil nil) + ("map" "Map(${1:key} -> ${2:value}) $0" "Map(key -> value)" nil nil nil nil nil) + ("match" "${1:cc} match {\n case ${2:pattern} => $0\n}" "cc match { .. }" nil nil nil nil nil) + ("match" "${1:option} match {\n case Full(res) => $0\n\n case Empty => \n\n case Failure(msg, _, _) => \n\n}" "can match { case Full(res) => .. }" nil nil nil nil nil) + ("match" "${1:option} match {\n case None => $0\n case Some(res) => \n\n}" "option match { case None => .. }" nil nil nil nil nil) + ("mix" "trait ${1:name} {\n $0\n}" "trait T { .. }" nil nil nil nil nil) + ("ob" "object ${1:name} extends ${2:type} $0" "object name extends T" nil nil nil nil nil) + ("pac" "package $0" "package .." nil nil nil nil nil) + ("pr" "println(${1:obj}) $0" "println(..)" nil nil nil nil nil) + ("pr" "print(${1:obj}) $0" "print(..)" nil nil nil nil nil) + ("pr" "println(\"${1:msg}\") $0" "println(\"..\")" nil nil nil nil nil) + ("pr" "println(\"${1:obj}: \" + ${1:obj}) $0" "println(\"obj: \" + obj)" nil nil nil nil nil) + ("pri" "private $0" "private" nil nil nil nil nil) + ("pri" "private[${1:this}] $0" "private[this]" nil nil nil nil nil) + ("pro" "protected $0" "protected" nil nil nil nil nil) + ("pro" "protected[${1:this}] $0" "protected[this]" nil nil nil nil nil) + ("suite" "import org.scalatest._\n\nclass ${1:name} extends Suite {\n $0\n}" "class T extends Suite { .. }" nil nil nil nil nil) + ("test" "//@Test\ndef test${1:name} = {\n $0\n}" "@Test def testX = ..." nil nil nil nil nil) + ("throw" "throw new ${1:Exception}(${2:msg}) $0" "throw new Exception" nil nil nil nil nil) + ("tr" "trait ${1:name} {\n $0\n}" "trait T { .. }" nil nil nil nil nil) + ("tr" "trait ${1:name} extends ${2:class} {\n $0\n}" "trait T extends C { .. }" nil nil nil nil nil) + ("tr" "trait ${1:name} extends ${2:class} with ${3:trait} {\n $0\n}" "trait T1 extends C with T2 { .. }" nil nil nil nil nil) + ("tr" "trait ${1:name} with ${2:trait} {\n $0\n}" "trait T1 with T2 { .. }" nil nil nil nil nil) + ("try" "try {\n $0\n} catch {\n case ${1:e}: ${2:Exception} => \n ${1:println(\\\"ERROR: \\\" + e) // TODO: handle exception}\\n}\n}" "try { .. } catch { case e => ..}" nil nil nil nil nil) + ("try" "try {\n $0\n} catch {\n case ${1:e}: ${2:Exception} => \n ${1:println(\\\"ERROR: \\\" + e) // TODO: handle exception}\\n}\n} finally {\n\n}" "try { .. } catch { case e => ..} finally { ..}" nil nil nil nil nil) + ("try" "try {\n\n} finally {\n $0\n}" "try { .. } finally { .. }" nil nil nil nil nil) + ("tup" "${1:element1} -> ${2:element2} $0" "element1 -> element2" nil nil nil nil nil) + ("tup" "(${1:element1}, ${2:element2}) $0" "(element1, element2)" nil nil nil nil nil) + ("val" "val ${1:name} = ${2:obj} $0" "val name = .." nil nil nil nil nil) + ("val" "val ${1:name} = new ${2:obj} $0" "val name = new .." nil nil nil nil nil) + ("val" "val ${1:name}: ${2:T} = ${3:obj} $0\n" "val name: T = .." nil nil nil nil nil) + ("var" "var ${1:name} = ${2:obj} $0\n" "var name = .." nil nil nil nil nil) + ("var" "var ${1:name} = new ${2:obj} $0\n" "var name = new .." nil nil nil nil nil) + ("var" "var ${1:name}: ${2:T} = ${3:obj} $0\n" "var name: T = .." nil nil nil nil nil) + ("whi" "while (${1:condition}) {\n $0\n}" "while(cond) { .. }" nil nil nil nil nil) + ("with" "with $0" "with T" nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for snippet-mode +(yas/define-snippets 'snippet-mode + '(("$f" "\\${${1:${2:n}:}$3${4:\\$(${5:lisp-fn})}\\}$0" "${ ... } field" nil nil nil nil nil) + ("$m" "\\${${2:n}:${4:\\$(${5:reflection-fn})}\\}$0" "${n:$(...)} mirror" nil nil nil nil nil) + ("vars" "# name : $1${2:\n# key : ${3:expand-key}}${4:\n# group : ${5:group}} \n# contributor : $6\n# --\n$0" "Snippet header" nil nil nil nil nil)) + '(text-mode)) + + +;;; snippets for sql-mode +(yas/define-snippets 'sql-mode + '(("column" " , ${1:Name} ${2:Type} ${3:NOT NULL}\n" ", ColumnName ColumnType NOT NULL..." nil nil nil nil nil) + ("constraint" "CONSTRAINT [${1:PK_Name}] PRIMARY KEY ${2:CLUSTERED} ([${3:ColumnName}]) \n" "CONSTRAINT [..] PRIMARY KEY ..." nil nil nil nil nil) + ("constraint" "CONSTRAINT [${1:FK_Name}] FOREIGN KEY ${2:CLUSTERED} ([${3:ColumnName}]) \n" "CONSTRAINT [..] FOREIGN KEY ..." nil nil nil nil nil) + ("create" "CREATE TABLE [${1:dbo}].[${2:TableName}] \n(\n ${3:Id} ${4:INT IDENTITY(1,1)} ${5:NOT NULL}\n$0\n CONSTRAINT [${6:PK_}] PRIMARY KEY ${7:CLUSTERED} ([$3]) \n)\nGO\n" "create table ..." nil nil nil nil nil) + ("create" "CREATE PROCEDURE [${1:dbo}].[${2:Name}] \n(\n $3 $4 = ${5:NULL} ${6:OUTPUT}\n)\nAS\nBEGIN\n$0\nEND\nGO\n" "create procedure ..." nil nil nil nil nil) + ("references" "REFERENCES ${1:TableName}([${2:ColumnName}])\n" "REFERENCES ..." nil nil nil nil nil)) + '(text-mode)) + + +(yas/global-mode 1) +) + +(yas/initialize-bundle) +;;;###autoload(require 'yasnippet-bundle) +(set-default 'yas/dont-activate + #'(lambda nil + (and + (or yas/root-directory + (featurep 'yasnippet-bundle)) + (null + (yas/get-snippet-tables))))) +(provide 'yasnippet-bundle) +;;; yasnippet-bundle.el ends here diff --git a/init.el b/init.el index 6d0c0b4a..7a22a390 100644 --- a/init.el +++ b/init.el @@ -34,6 +34,9 @@ (ido-mode t) (setq ido-enable-flex-matching t) +;; Code Completion. +(require 'yasnippet-bundle) + ;; Give duplicate open buffers better titles. (require 'uniquify) (setq uniquify-buffer-name-style 'forward)