diff options
Diffstat (limited to 'emacs.d')
| -rw-r--r-- | emacs.d/yasnippet/yasnippet.el | 3676 |
1 files changed, 3676 insertions, 0 deletions
diff --git a/emacs.d/yasnippet/yasnippet.el b/emacs.d/yasnippet/yasnippet.el new file mode 100644 index 0000000..fcbce9e --- /dev/null +++ b/emacs.d/yasnippet/yasnippet.el @@ -0,0 +1,3676 @@ +;;; Yasnippet.el --- Yet another snippet extension for Emacs. + +;; Copyright 2008 pluskid +;; 2009 pluskid, joaotavora + +;; Authors: pluskid <pluskid@gmail.com>, joaotavora <joaotavora@gmail.com> +;; Version: 0.6.1 +;; Package-version: 0.6.1c +;; 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" "<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 '("<backtab>" "<S-tab>") + "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 <pluskid@gmail.com>/joaotavora <joaotavora@gmail.com>"))) + +(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 |