[Date Prev][Date Next][Thread Prev][Thread Next][Date Index][Thread Index]
[ELPA-diffs] ELPA branch, master, updated. a8eda6e7dfd43b448119fd3b607dc
|
From: |
Stefan Monnier |
|
Subject: |
[ELPA-diffs] ELPA branch, master, updated. a8eda6e7dfd43b448119fd3b607dc6c5c9af5c5c |
|
Date: |
Thu, 29 Aug 2013 14:24:56 +0000 |
This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "ELPA".
The branch, master has been updated
via a8eda6e7dfd43b448119fd3b607dc6c5c9af5c5c (commit)
via 13d87aa3c0b0289ed918bab545d2b423974688a5 (commit)
from 4be159342d0fd11da2a680c038f5fcc2112ea54f (commit)
Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.
- Log -----------------------------------------------------------------
commit a8eda6e7dfd43b448119fd3b607dc6c5c9af5c5c
Merge: 4be1593 13d87aa
Author: Stefan Monnier <address@hidden>
Date: Thu Aug 29 10:24:48 2013 -0400
Sync with yasnippet/master
diff --cc packages/yasnippet/yasnippet-tests.el
index 6b3993e,0000000..db1fe55
mode 100644,000000..100644
--- a/packages/yasnippet/yasnippet-tests.el
+++ b/packages/yasnippet/yasnippet-tests.el
@@@ -1,617 -1,0 +1,651 @@@
+;;; yasnippet-tests.el --- some yasnippet tests
+
+;; Copyright (C) 2012, 2013 Free Software Foundation, Inc.
+
+;; Author: João Távora <address@hidden>
+;; Keywords: emulations, convenience
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; Test basic snippet mechanics and the loading system
+
+;;; Code:
+
+(require 'yasnippet)
+(require 'ert)
+(require 'ert-x)
+
+
+;;; Snippet mechanics
+
+(defun yas--buffer-contents ()
+ (buffer-substring-no-properties (point-min) (point-max)))
+
+(ert-deftest field-navigation ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "${1:brother} from another ${2:mother}")
+ (should (string= (yas--buffer-contents)
+ "brother from another mother"))
+
+ (should (looking-at "brother"))
+ (ert-simulate-command '(yas-next-field-or-maybe-expand))
+ (should (looking-at "mother"))
+ (ert-simulate-command '(yas-prev-field))
+ (should (looking-at "brother"))))
+
+(ert-deftest simple-mirror ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "${1:brother} from another $1")
+ (should (string= (yas--buffer-contents)
+ "brother from another brother"))
+ (ert-simulate-command `(yas-mock-insert "bla"))
+ (should (string= (yas--buffer-contents)
+ "bla from another bla"))))
+
+(ert-deftest mirror-with-transformation ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "${1:brother} from another ${1:$(upcase yas-text)}")
+ (should (string= (yas--buffer-contents)
+ "brother from another BROTHER"))
+ (ert-simulate-command `(yas-mock-insert "bla"))
+ (should (string= (yas--buffer-contents)
+ "bla from another BLA"))))
+
+(ert-deftest primary-field-transformation ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (let ((snippet "${1:$$(upcase yas/text)}${1:$(concat \"bar\" yas/text)}"))
+ (yas-expand-snippet snippet)
+ (should (string= (yas--buffer-contents) "bar"))
+ (ert-simulate-command `(yas-mock-insert "foo"))
+ (should (string= (yas--buffer-contents) "FOObarFOO")))))
+
+(ert-deftest nested-placeholders-kill-superfield ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "brother from ${2:another ${3:mother}}!")
+ (should (string= (yas--buffer-contents)
+ "brother from another mother!"))
+ (ert-simulate-command `(yas-mock-insert "bla"))
+ (should (string= (yas--buffer-contents)
+ "brother from bla!"))))
+
+(ert-deftest nested-placeholders-use-subfield ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "brother from ${2:another ${3:mother}}!")
+ (ert-simulate-command '(yas-next-field-or-maybe-expand))
+ (ert-simulate-command `(yas-mock-insert "bla"))
+ (should (string= (yas--buffer-contents)
+ "brother from another bla!"))))
+
+(ert-deftest mirrors-adjacent-to-fields-with-nested-mirrors ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "<%= f.submit \"${1:Submit}\"${2:$(and (yas-text) \",
:disable_with => '\")}${2:$1ing...}${2:$(and (yas-text) \"'\")} %>")
+ (should (string= (yas--buffer-contents)
+ "<%= f.submit \"Submit\", :disable_with =>
'Submiting...' %>"))
+ (ert-simulate-command `(yas-mock-insert "Send"))
+ (should (string= (yas--buffer-contents)
+ "<%= f.submit \"Send\", :disable_with => 'Sending...'
%>"))))
+
+(ert-deftest deep-nested-mirroring-issue-351 ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "${1:FOOOOOOO}${2:$1}${3:$2}${4:$3}")
+ (ert-simulate-command `(yas-mock-insert "abc"))
+ (should (string= (yas--buffer-contents) "abcabcabcabc"))))
+
+;; (ert-deftest in-snippet-undo ()
+;; (with-temp-buffer
+;; (yas-minor-mode 1)
+;; (yas-expand-snippet "brother from ${2:another ${3:mother}}!")
+;; (ert-simulate-command '(yas-next-field-or-maybe-expand))
+;; (ert-simulate-command `(yas-mock-insert "bla"))
+;; (ert-simulate-command '(undo))
+;; (should (string= (yas--buffer-contents)
+;; "brother from another mother!"))))
+
+
+;;; Snippet expansion and character escaping
+;;; Thanks to @zw963 (Billy) for the testing
+;;;
+(ert-deftest escape-dollar ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "bla\\${1:bla}ble")
+ (should (string= (yas--buffer-contents) "bla${1:bla}ble"))))
+
+(ert-deftest escape-closing-brace ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "bla${1:bla\\}}ble")
+ (should (string= (yas--buffer-contents) "blabla}ble"))
+ (should (string= (yas-field-value 1) "bla}"))))
+
+(ert-deftest escape-backslashes ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "bla\\ble")
+ (should (string= (yas--buffer-contents) "bla\\ble"))))
+
+(ert-deftest escape-backquotes ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "bla`(upcase \"foo\\`bar\")`ble")
+ (should (string= (yas--buffer-contents) "blaFOO`BARble"))))
+
+(ert-deftest escape-some-elisp-with-strings ()
+ "elisp with strings and unbalance parens inside it"
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ ;; The rules here is: to output a literal `"' you need to escape
+ ;; it with one backslash. You don't need to escape them in
+ ;; embedded elisp.
+ (yas-expand-snippet "soon \\\"`(concat (upcase \"(my arms\")\"\\\" were
all around her\")`")
+ (should (string= (yas--buffer-contents) "soon \"(MY ARMS\" were all
around her"))))
+
+(ert-deftest escape-some-elisp-with-backslashes ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ ;; And the rule here is: to output a literal `\' inside a string
+ ;; inside embedded elisp you need a total of six `\'
+ (yas-expand-snippet "bla`(upcase \"hey\\\\\\yo\")`ble")
+ (should (string= (yas--buffer-contents) "blaHEY\\YOble"))))
+
+(ert-deftest be-careful-when-escaping-in-yas-selected-text ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (let ((yas/selected-text "He\\\\o world!"))
+ (yas-expand-snippet "Look ma! `(yas/selected-text)`")
+ (should (string= (yas--buffer-contents) "Look ma! He\\\\o world!")))
+ (yas-exit-all-snippets)
+ (erase-buffer)
+ (let ((yas/selected-text "He\"o world!"))
+ (yas-expand-snippet "Look ma! `(yas/selected-text)`")
+ (should (string= (yas--buffer-contents) "Look ma! He\"o world!")))
+ (yas-exit-all-snippets)
+ (erase-buffer)
+ (let ((yas/selected-text "He\"\)\\o world!"))
+ (yas-expand-snippet "Look ma! `(yas/selected-text)`")
+ (should (string= (yas--buffer-contents) "Look ma! He\"\)\\o world!")))
+ (yas-exit-all-snippets)
+ (erase-buffer)))
+
+(ert-deftest be-careful-when-escaping-in-yas-selected-text-2 ()
+ (with-temp-buffer
+ (let ((yas/selected-text "He)}o world!"))
+ (yas-expand-snippet "Look ma! ${1:`(yas/selected-text)`} OK?")
+ (should (string= (yas--buffer-contents) "Look ma! He)}o world! OK?")))))
+
+(ert-deftest example-for-issue-271 ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (let ((yas-selected-text "aaa")
+ (snippet "if ${1:condition}\n`yas/selected-text`\nelse\n$3\nend"))
+ (yas-expand-snippet snippet)
+ (yas-next-field)
+ (ert-simulate-command `(yas-mock-insert "bbb"))
+ (should (string= (yas--buffer-contents) "if
condition\naaa\nelse\nbbb\nend")))))
+
+(ert-deftest another-example-for-issue-271 ()
+ ;; expect this to fail in batch mode since `region-active-p' doesn't
+ ;; used by `yas-expand-snippet' doesn't make sense in that context.
+ ;;
+ :expected-result (if noninteractive
+ :failed
+ :passed)
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (let ((snippet "\\${${1:1}:`yas/selected-text`}"))
+ (insert "aaabbbccc")
+ (set-mark 4)
+ (goto-char 7)
+ (yas-expand-snippet snippet)
+ (should (string= (yas--buffer-contents) "aaa${1:bbb}ccc")))))
+
+(ert-deftest string-match-with-subregexp-in-embedded-elisp ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ ;; the rule here is: To use regexps in embedded `(elisp)` expressions,
write
+ ;; it like you would normal elisp, i.e. no need to escape the backslashes.
+ (let ((snippet "`(if (string-match \"foo\\\\(ba+r\\\\)foo\"
\"foobaaaaaaaaaarfoo\")
+ \"ok\"
+ \"fail\")`"))
+ (yas-expand-snippet snippet))
+ (should (string= (yas--buffer-contents) "ok"))))
+
+(ert-deftest string-match-with-subregexp-in-mirror-transformations ()
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ ;; the rule here is: To use regexps in embedded `(elisp)` expressions,
+ ;; escape backslashes once, i.e. to use \\( \\) constructs, write \\\\(
\\\\).
+ (let ((snippet "$1${1:$(if (string-match \"foo\\\\\\\\(ba+r\\\\\\\\)baz\"
yas/text)
+ \"ok\"
+ \"fail\")}"))
+ (yas-expand-snippet snippet)
+ (should (string= (yas--buffer-contents) "fail"))
+ (ert-simulate-command `(yas-mock-insert "foobaaar"))
+ (should (string= (yas--buffer-contents) "foobaaarfail"))
+ (ert-simulate-command `(yas-mock-insert "baz"))
+ (should (string= (yas--buffer-contents) "foobaaarbazok")))))
+
+
+;;; Misc tests
+;;;
+(ert-deftest protection-overlay-no-cheating ()
+ "Protection overlays at the very end of the buffer are dealt
+ with by cheatingly inserting a newline!
+
+TODO: correct this bug!"
+ :expected-result :failed
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (yas-expand-snippet "${2:brother} from another ${1:mother}")
+ (should (string= (yas--buffer-contents)
+ "brother from another mother") ;; no newline should be
here!
+ )))
+
+;;; Loading
+;;;
++(defun yas--call-with-temporary-redefinitions (function
++ &rest
function-names-and-overriding-functions)
++ (let* ((overrides (remove-if-not #'(lambda (fdef)
++ (fboundp (first fdef)))
++ function-names-and-overriding-functions))
++ (definition-names (mapcar #'first overrides))
++ (overriding-functions (mapcar #'second overrides))
++ (saved-functions (mapcar #'symbol-function definition-names)))
++ ;; saving all definitions before overriding anything ensures FDEFINITION
++ ;; errors don't cause accidental permanent redefinitions.
++ ;;
++ (labels ((set-fdefinitions (names functions)
++ (loop for name in names
++ for fn in functions
++ do (fset name fn))))
++ (set-fdefinitions definition-names overriding-functions)
++ (unwind-protect (funcall function)
++ (set-fdefinitions definition-names saved-functions)))))
++
++(defmacro yas--with-temporary-redefinitions (fdefinitions &rest body)
++ ;; "Temporarily (but globally) redefine each function in FDEFINITIONS.
++ ;; E.g.: (yas--with-temporary-redefinitions ((foo (x) ...)
++ ;; (bar (x) ...))
++ ;; ;; code that eventually calls foo, bar of (setf foo)
++ ;; ...)"
++ ;; FIXME: This is hideous! Better use defadvice (or at least letf).
++ `(yas--call-with-temporary-redefinitions
++ (lambda () ,@body)
++ ,@(mapcar #'(lambda (thingy)
++ `(list ',(first thingy)
++ (lambda ,@(rest thingy))))
++ fdefinitions)))
++
++(put 'yas--with-temporary-redefinitions 'lisp-indent-function 1)
++(put 'yas--with-temporary-redefinitions 'edebug-form-spec '((&rest (defun*))
cl-declarations body))
++
+(defmacro yas-with-overriden-buffer-list (&rest body)
- (let ((saved-sym (gensym)))
++ (let ((saved-sym (make-symbol "yas--buffer-list")))
+ `(let ((,saved-sym (symbol-function 'buffer-list)))
+ (yas--with-temporary-redefinitions
+ ((buffer-list ()
+ (remove-if #'(lambda (buf)
+ (with-current-buffer buf
+ (eq major-mode
'lisp-interaction-mode)))
+ (funcall ,saved-sym))))
+ ,@body))))
+
+(defmacro yas-with-some-interesting-snippet-dirs (&rest body)
+ `(yas-saving-variables
+ (yas-with-overriden-buffer-list
+ (yas-with-snippet-dirs
+ '((".emacs.d/snippets"
+ ("c-mode"
+ (".yas-parents" . "cc-mode")
+ ("printf" . "printf($1);")) ;; notice the overriding for issue
#281
+ ("emacs-lisp-mode" ("ert-deftest" . "(ert-deftest ${1:name} ()
$0)"))
+ ("lisp-interaction-mode" (".yas-parents" . "emacs-lisp-mode")))
+ ("library/snippets"
+ ("c-mode"
+ (".yas-parents" . "c++-mode")
+ ("printf" . "printf"))
+ ("cc-mode" ("def" . "# define"))
+ ("emacs-lisp-mode" ("dolist" . "(dolist)"))
+ ("lisp-interaction-mode" ("sc" . "brother from another mother"))))
+ ,@body))))
+
+(ert-deftest basic-jit-loading ()
+ "Test basic loading and expansion of snippets"
+ (yas-with-some-interesting-snippet-dirs
+ (yas-reload-all)
+ (yas--basic-jit-loading-1)))
+
+(ert-deftest basic-jit-loading-with-compiled-snippets ()
+ "Test basic loading and expansion of snippets"
+ (yas-with-some-interesting-snippet-dirs
+ (yas-reload-all)
+ (yas-recompile-all)
+ (yas--with-temporary-redefinitions ((yas--load-directory-2
- (&rest dummies)
- (declare (ignore dummies))
++ (&rest _dummies)
+ (ert-fail "yas--load-directory-2
shouldn't be called when snippets have been compiled")))
+ (yas-reload-all)
+ (yas--basic-jit-loading-1))))
+
+(ert-deftest loading-with-cyclic-parenthood ()
+ "Test loading when cyclic parenthood is setup."
+ (yas-saving-variables
+ (yas-with-snippet-dirs '((".emacs.d/snippets"
+ ("c-mode"
+ (".yas-parents" . "cc-mode"))
+ ("cc-mode"
+ (".yas-parents" . "yet-another-c-mode"))
+ ("yet-another-c-mode"
+ (".yas-parents" . "c-mode"))))
+ (yas-reload-all)
+ (condition-case nil
+ (yas--all-parents 'c-mode)
+ (error
+ (ert-fail "cyclic parenthood test failed"))))))
+
- (defun yas--basic-jit-loading-1 (&optional compile)
++(defun yas--basic-jit-loading-1 ()
+ (with-temp-buffer
+ (should (= 4 (hash-table-count yas--scheduled-jit-loads)))
+ (should (= 0 (hash-table-count yas--tables)))
+ (lisp-interaction-mode)
+ (yas-minor-mode 1)
+ (should (= 2 (hash-table-count yas--scheduled-jit-loads)))
+ (should (= 2 (hash-table-count yas--tables)))
+ (should (= 1 (hash-table-count (yas--table-uuidhash (gethash
'lisp-interaction-mode yas--tables)))))
+ (should (= 2 (hash-table-count (yas--table-uuidhash (gethash
'emacs-lisp-mode yas--tables)))))
+ (yas-should-expand '(("sc" . "brother from another mother")
+ ("dolist" . "(dolist)")
+ ("ert-deftest" . "(ert-deftest name () )")))
+ (c-mode)
+ (yas-minor-mode 1)
+ (should (= 0 (hash-table-count yas--scheduled-jit-loads)))
+ (should (= 4 (hash-table-count yas--tables)))
+ (should (= 1 (hash-table-count (yas--table-uuidhash (gethash 'c-mode
yas--tables)))))
+ (should (= 1 (hash-table-count (yas--table-uuidhash (gethash 'cc-mode
yas--tables)))))
+ (yas-should-expand '(("printf" . "printf();")
+ ("def" . "# define")))
+ (yas-should-not-expand '("sc" "dolist" "ert-deftest"))))
+
+
+;;; Menu
+;;;
+(defmacro yas-with-even-more-interesting-snippet-dirs (&rest body)
+ `(yas-saving-variables
+ (yas-with-snippet-dirs
+ `((".emacs.d/snippets"
+ ("c-mode"
+ (".yas-make-groups" . "")
+ ("printf" . "printf($1);")
+ ("foo-group-a"
+ ("fnprintf" . "fprintf($1);")
+ ("snprintf" . "snprintf($1);"))
+ ("foo-group-b"
+ ("strcmp" . "strecmp($1);")
+ ("strcasecmp" . "strcasecmp($1);")))
+ ("lisp-interaction-mode"
+ ("ert-deftest" . "# group: barbar\n# --\n(ert-deftest ${1:name} ()
$0)"))
+ ("fancy-mode"
+ ("a-guy" . "# uuid: 999\n# --\nyo!")
+ ("a-sir" . "# uuid: 12345\n# --\nindeed!")
+ ("a-lady" . "# uuid: 54321\n# --\noh-la-la!")
+ ("a-beggar" . "# uuid: 0101\n# --\narrrgh!")
+ ("an-outcast" . "# uuid: 666\n# --\narrrgh!")
+ (".yas-setup.el" . , (pp-to-string
+ '(yas-define-menu 'fancy-mode
+ '((yas-ignore-item "0101")
+ (yas-item "999")
+ (yas-submenu "sirs"
+ ((yas-item
"12345")))
+ (yas-submenu "ladies"
+ ((yas-item
"54321"))))
+ '("666")))))))
+ ,@body)))
+
+(ert-deftest test-yas-define-menu ()
+ (let ((yas-use-menu t))
+ (yas-with-even-more-interesting-snippet-dirs
+ (yas-reload-all 'no-jit)
+ (let ((menu (cdr (gethash 'fancy-mode yas--menu-table))))
+ (should (eql 4 (length menu)))
+ (dolist (item '("a-guy" "a-beggar"))
+ (should (find item menu :key #'third :test #'string=)))
+ (should-not (find "an-outcast" menu :key #'third :test #'string=))
+ (dolist (submenu '("sirs" "ladies"))
+ (should (keymapp
+ (fourth
+ (find submenu menu :key #'third :test #'string=)))))
+ ))))
+
+(ert-deftest test-group-menus ()
+ "Test group-based menus using .yas-make-groups and the group directive"
+ (let ((yas-use-menu t))
+ (yas-with-even-more-interesting-snippet-dirs
+ (yas-reload-all 'no-jit)
+ ;; first the subdir-based groups
+ ;;
+ (let ((menu (cdr (gethash 'c-mode yas--menu-table))))
+ (should (eql 3 (length menu)))
+ (dolist (item '("printf" "foo-group-a" "foo-group-b"))
+ (should (find item menu :key #'third :test #'string=)))
+ (dolist (submenu '("foo-group-a" "foo-group-b"))
+ (should (keymapp
+ (fourth
+ (find submenu menu :key #'third :test #'string=))))))
+ ;; now group directives
+ ;;
+ (let ((menu (cdr (gethash 'lisp-interaction-mode yas--menu-table))))
+ (should (eql 1 (length menu)))
+ (should (find "barbar" menu :key #'third :test #'string=))
+ (should (keymapp
+ (fourth
+ (find "barbar" menu :key #'third :test #'string=))))))))
+
+(ert-deftest test-group-menus-twisted ()
+ "Same as similarly named test, but be mean.
+
+TODO: be meaner"
+ (let ((yas-use-menu t))
+ (yas-with-even-more-interesting-snippet-dirs
+ ;; add a group directive conflicting with the subdir and watch
+ ;; behaviour
+ (with-temp-buffer
+ (insert "# group: foo-group-c\n# --\nstrecmp($1)")
+ (write-region nil nil (concat (first (yas-snippet-dirs))
+ "/c-mode/foo-group-b/strcmp")))
+ (yas-reload-all 'no-jit)
+ (let ((menu (cdr (gethash 'c-mode yas--menu-table))))
+ (should (eql 4 (length menu)))
+ (dolist (item '("printf" "foo-group-a" "foo-group-b" "foo-group-c"))
+ (should (find item menu :key #'third :test #'string=)))
+ (dolist (submenu '("foo-group-a" "foo-group-b" "foo-group-c"))
+ (should (keymapp
+ (fourth
+ (find submenu menu :key #'third :test #'string=))))))
+ ;; delete the .yas-make-groups file and watch behaviour
+ ;;
+ (delete-file (concat (first (yas-snippet-dirs))
+ "/c-mode/.yas-make-groups"))
+ (yas-reload-all 'no-jit)
+ (let ((menu (cdr (gethash 'c-mode yas--menu-table))))
+ (should (eql 5 (length menu))))
+ ;; Change a group directive and reload
+ ;;
+ (let ((menu (cdr (gethash 'lisp-interaction-mode yas--menu-table))))
+ (should (find "barbar" menu :key #'third :test #'string=)))
+
+ (with-temp-buffer
+ (insert "# group: foofoo\n# --\n(ert-deftest ${1:name} () $0)")
+ (write-region nil nil (concat (first (yas-snippet-dirs))
+ "/lisp-interaction-mode/ert-deftest")))
+ (yas-reload-all 'no-jit)
+ (let ((menu (cdr (gethash 'lisp-interaction-mode yas--menu-table))))
+ (should (eql 1 (length menu)))
+ (should (find "foofoo" menu :key #'third :test #'string=))
+ (should (keymapp
+ (fourth
+ (find "foofoo" menu :key #'third :test #'string=))))))))
+
+
+;;; The infamous and problematic tab keybinding
+;;;
+(ert-deftest test-yas-tab-binding ()
+ (with-temp-buffer
+ (yas-minor-mode -1)
+ (should (not (eq (key-binding (yas--read-keybinding "<tab>"))
'yas-expand)))
+ (yas-minor-mode 1)
+ (should (eq (key-binding (yas--read-keybinding "<tab>")) 'yas-expand))
+ (yas-expand-snippet "$1 $2 $3")
+ (should (eq (key-binding [(tab)]) 'yas-next-field-or-maybe-expand))
+ (should (eq (key-binding (kbd "TAB")) 'yas-next-field-or-maybe-expand))
+ (should (eq (key-binding [(shift tab)]) 'yas-prev-field))
+ (should (eq (key-binding [backtab]) 'yas-prev-field))))
+
+(ert-deftest test-rebindings ()
+ (unwind-protect
+ (progn
+ (define-key yas-minor-mode-map [tab] nil)
+ (define-key yas-minor-mode-map (kbd "TAB") nil)
+ (define-key yas-minor-mode-map (kbd "SPC") 'yas-expand)
+ (with-temp-buffer
+ (yas-minor-mode 1)
+ (should (not (eq (key-binding (yas--read-keybinding "TAB"))
'yas-expand)))
+ (should (eq (key-binding (yas--read-keybinding "SPC")) 'yas-expand))
+ (yas-reload-all)
+ (should (not (eq (key-binding (yas--read-keybinding "TAB"))
'yas-expand)))
+ (should (eq (key-binding (yas--read-keybinding "SPC"))
'yas-expand))))
+ (setcdr yas-minor-mode-map (cdr (yas--init-minor-keymap)))))
+
+(ert-deftest test-yas-in-org ()
+ (with-temp-buffer
+ (org-mode)
+ (yas-minor-mode 1)
+ (should (eq (key-binding [(tab)]) 'yas-expand))
+ (should (eq (key-binding (kbd "TAB")) 'yas-expand))))
+
+
+;;; Helpers
+;;;
+(defun yas/ert ()
+ (interactive)
+ (with-temp-buffer
+ (yas--with-temporary-redefinitions
- ((message (&rest args) ;
- (declare (ignore args))
- nil))
++ ((message (&rest _args) nil))
+ (ert t (buffer-name (current-buffer)))
+ (princ (buffer-string)))))
+
+
+(defun yas-should-expand (keys-and-expansions)
+ (dolist (key-and-expansion keys-and-expansions)
+ (yas-exit-all-snippets)
+ (erase-buffer)
+ (insert (car key-and-expansion))
+ (let ((yas-fallback-behavior nil))
+ (ert-simulate-command '(yas-expand)))
+ (should (string= (yas--buffer-contents) (cdr key-and-expansion))))
+ (yas-exit-all-snippets))
+
+(defun yas-should-not-expand (keys)
+ (dolist (key keys)
+ (yas-exit-all-snippets)
+ (erase-buffer)
+ (insert key)
+ (let ((yas-fallback-behavior nil))
+ (ert-simulate-command '(yas-expand)))
+ (should (string= (yas--buffer-contents) key))))
+
+(defun yas-mock-insert (string)
+ (interactive)
+ (do ((i 0 (1+ i)))
+ ((= i (length string)))
+ (insert (aref string i))))
+
+(defun yas-make-file-or-dirs (ass)
+ (let ((file-or-dir-name (car ass))
+ (content (cdr ass)))
+ (cond ((listp content)
+ (make-directory file-or-dir-name 'parents)
+ (let ((default-directory (concat default-directory "/"
file-or-dir-name)))
+ (mapc #'yas-make-file-or-dirs content)))
+ ((stringp content)
+ (with-temp-buffer
+ (insert content)
+ (write-region nil nil file-or-dir-name nil 'nomessage)))
+ (t
+ (message "[yas] oops don't know this content")))))
+
+
+(defun yas-variables ()
+ (let ((syms))
+ (mapatoms #'(lambda (sym)
+ (if (and (string-match "^yas-[^/]" (symbol-name sym))
+ (boundp sym))
+ (push sym syms))))
+ syms))
+
+(defun yas-call-with-saving-variables (fn)
+ (let* ((vars (yas-variables))
+ (saved-values (mapcar #'symbol-value vars)))
+ (unwind-protect
+ (funcall fn)
+ (loop for var in vars
+ for saved in saved-values
+ do (set var saved)))))
+
+(defmacro yas-saving-variables (&rest body)
+ `(yas-call-with-saving-variables #'(lambda () ,@body)))
+
+
+(defun yas-call-with-snippet-dirs (dirs fn)
+ (let* ((default-directory (make-temp-file "yasnippet-fixture" t))
+ (yas-snippet-dirs (mapcar #'car dirs)))
+ (with-temp-message ""
+ (unwind-protect
+ (progn
+ (mapc #'yas-make-file-or-dirs dirs)
+ (funcall fn))
+ (when (>= emacs-major-version 24)
+ (delete-directory default-directory 'recursive))))))
+
+(defmacro yas-with-snippet-dirs (dirs &rest body)
+ (declare (indent defun))
+ `(yas-call-with-snippet-dirs ,dirs
+ #'(lambda ()
+ ,@body)))
+
+;;; Older emacsen
+;;;
+(unless (fboundp 'special-mode)
- (define-minor-mode special-mode "Just a placeholder for something isn't in
emacs 22"))
++ ;; FIXME: Why provide this default definition here?!?
++ (defalias 'special-mode 'fundamental))
+
+;;; btw to test this in emacs22 mac osx:
+;;; curl -L -O
https://github.com/mirrors/emacs/raw/master/lisp/emacs-lisp/ert.el
+;;; curl -L -O
https://github.com/mirrors/emacs/raw/master/lisp/emacs-lisp/ert-x.el
+;;; /usr/bin/emacs -nw -Q -L . -l yasnippet-tests.el --batch -e ert
+
+
+(provide 'yasnippet-tests)
+;;; yasnippet-tests.el ends here
+;; Local Variables:
+;; lexical-binding: t
+;; End:
commit 13d87aa3c0b0289ed918bab545d2b423974688a5
Author: Joao Tavora <address@hidden>
Date: Thu Aug 29 10:20:31 2013 +0100
fix: more idiomatic elisp, better docstrings, less byte-compiler warnings
By Stefan Monnier, with original commentary.
"Here's an untested patch of cleanups, found partly via compilation using
lexical-binding and partly via checkdoc-current-buffer (and
occasionally by stumble-upon happenstance)."
diff --git a/yasnippet-tests.el b/yasnippet-tests.el
index 257fd24..3bc98f1 100644
--- a/yasnippet-tests.el
+++ b/yasnippet-tests.el
@@ -264,8 +264,44 @@ TODO: correct this bug!"
;;; Loading
;;;
+(defun yas--call-with-temporary-redefinitions (function
+ &rest
function-names-and-overriding-functions)
+ (let* ((overrides (remove-if-not #'(lambda (fdef)
+ (fboundp (first fdef)))
+ function-names-and-overriding-functions))
+ (definition-names (mapcar #'first overrides))
+ (overriding-functions (mapcar #'second overrides))
+ (saved-functions (mapcar #'symbol-function definition-names)))
+ ;; saving all definitions before overriding anything ensures FDEFINITION
+ ;; errors don't cause accidental permanent redefinitions.
+ ;;
+ (labels ((set-fdefinitions (names functions)
+ (loop for name in names
+ for fn in functions
+ do (fset name fn))))
+ (set-fdefinitions definition-names overriding-functions)
+ (unwind-protect (funcall function)
+ (set-fdefinitions definition-names saved-functions)))))
+
+(defmacro yas--with-temporary-redefinitions (fdefinitions &rest body)
+ ;; "Temporarily (but globally) redefine each function in FDEFINITIONS.
+ ;; E.g.: (yas--with-temporary-redefinitions ((foo (x) ...)
+ ;; (bar (x) ...))
+ ;; ;; code that eventually calls foo, bar of (setf foo)
+ ;; ...)"
+ ;; FIXME: This is hideous! Better use defadvice (or at least letf).
+ `(yas--call-with-temporary-redefinitions
+ (lambda () ,@body)
+ ,@(mapcar #'(lambda (thingy)
+ `(list ',(first thingy)
+ (lambda ,@(rest thingy))))
+ fdefinitions)))
+
+(put 'yas--with-temporary-redefinitions 'lisp-indent-function 1)
+(put 'yas--with-temporary-redefinitions 'edebug-form-spec '((&rest (defun*))
cl-declarations body))
+
(defmacro yas-with-overriden-buffer-list (&rest body)
- (let ((saved-sym (gensym)))
+ (let ((saved-sym (make-symbol "yas--buffer-list")))
`(let ((,saved-sym (symbol-function 'buffer-list)))
(yas--with-temporary-redefinitions
((buffer-list ()
@@ -306,8 +342,7 @@ TODO: correct this bug!"
(yas-reload-all)
(yas-recompile-all)
(yas--with-temporary-redefinitions ((yas--load-directory-2
- (&rest dummies)
- (declare (ignore dummies))
+ (&rest _dummies)
(ert-fail "yas--load-directory-2
shouldn't be called when snippets have been compiled")))
(yas-reload-all)
(yas--basic-jit-loading-1))))
@@ -328,7 +363,7 @@ TODO: correct this bug!"
(error
(ert-fail "cyclic parenthood test failed"))))))
-(defun yas--basic-jit-loading-1 (&optional compile)
+(defun yas--basic-jit-loading-1 ()
(with-temp-buffer
(should (= 4 (hash-table-count yas--scheduled-jit-loads)))
(should (= 0 (hash-table-count yas--tables)))
@@ -514,9 +549,7 @@ TODO: be meaner"
(interactive)
(with-temp-buffer
(yas--with-temporary-redefinitions
- ((message (&rest args) ;
- (declare (ignore args))
- nil))
+ ((message (&rest _args) nil))
(ert t (buffer-name (current-buffer)))
(princ (buffer-string)))))
@@ -602,7 +635,8 @@ TODO: be meaner"
;;; Older emacsen
;;;
(unless (fboundp 'special-mode)
- (define-minor-mode special-mode "Just a placeholder for something isn't in
emacs 22"))
+ ;; FIXME: Why provide this default definition here?!?
+ (defalias 'special-mode 'fundamental))
;;; btw to test this in emacs22 mac osx:
;;; curl -L -O
https://github.com/mirrors/emacs/raw/master/lisp/emacs-lisp/ert.el
diff --git a/yasnippet.el b/yasnippet.el
index b279f12..aa3e312 100644
--- a/yasnippet.el
+++ b/yasnippet.el
@@ -1,7 +1,8 @@
;;; yasnippet.el --- Yet another snippet extension for Emacs.
-;; Copyright (C) 2008-2012 Free Software Foundation, Inc.
+;; Copyright (C) 2008-2013 Free Software Foundation, Inc.
;; Authors: pluskid <address@hidden>, João Távora <address@hidden>
+;; Maintainer: João Távora <address@hidden>
;; Version: 0.8.0
;; Package-version: 0.8.0
;; X-URL: http://github.com/capitaomorte/yasnippet
@@ -137,15 +138,14 @@
(require 'easymenu)
(require 'help-mode)
-(eval-when-compile
- (defvar yas--editing-template)
- (defvar yas--guessed-modes)
- (defvar yas--indent-original-column)
- (defvar yas--scheduled-jit-loads)
- (defvar yas-keymap)
- (defvar yas-selected-text)
- (defvar yas-verbosity))
-
+(defvar yas--editing-template)
+(defvar yas--guessed-modes)
+(defvar yas--indent-original-column)
+(defvar yas--scheduled-jit-loads)
+(defvar yas-keymap)
+(defvar yas-selected-text)
+(defvar yas-verbosity)
+(defvar yas--current-template)
;;; User customizable variables
@@ -182,7 +182,7 @@ as the default for storing the user's new snippets."
(yas-reload-all)))))
(defun yas-snippet-dirs ()
- "Returns `yas-snippet-dirs' (which see) as a list."
+ "Return `yas-snippet-dirs' (which see) as a list."
(if (listp yas-snippet-dirs) yas-snippet-dirs (list yas-snippet-dirs)))
(defvaralias 'yas/root-directory 'yas-snippet-dirs)
@@ -196,8 +196,8 @@ as the default for storing the user's new snippets."
# type: command}
# --
$0"
- "Default snippet to use when creating a new snippet. If nil,
-don't use any snippet."
+ "Default snippet to use when creating a new snippet.
+If nil, don't use any snippet."
:type 'string
:group 'yasnippet)
@@ -770,18 +770,19 @@ If a function of zero arguments, then its result is used.
If a list of functions, then all functions must return nil to
activate yas for this buffer.
-In Emacsen <= 23, this variable is buffer-local. Because
+In Emacsen <= 23, this variable is buffer-local. Because
`yas-minor-mode-on' is called by `yas-global-mode' after
executing the buffer's major mode hook, setting this variable
there is an effective way to define exceptions to the \"global\"
activation behaviour.
-In Emacsen > 23, only the global value is used. To define
+In Emacsen > 23, only the global value is used. To define
per-mode exceptions to the \"global\" activation behaviour, call
`yas-minor-mode' with a negative argument directily in the major
mode's hook.")
(unless (> emacs-major-version 23)
- (make-variable-buffer-local 'yas-dont-activate))
+ (with-no-warnings
+ (make-variable-buffer-local 'yas-dont-activate)))
(defun yas-minor-mode-on ()
@@ -828,8 +829,7 @@ Honour `yas-dont-activate', which see."
("}"
(0 font-lock-keyword-face)))))
-(defun yas--init-major-keymap ()
- "Setup YASnippet major-mode keymap."
+(defvar snippet-mode-map
(let ((map (make-sparse-keymap)))
(easy-menu-define nil
map
@@ -839,13 +839,9 @@ Honour `yas-dont-activate', which see."
(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)
+ '(("Load this snippet" yas-load-snippet-buffer "\C-c\C-c")
+ ("Try out this snippet" yas-tryout-snippet
"\C-c\C-t")))))
+ map)
"The keymap used when `snippet-mode' is active.")
@@ -878,14 +874,13 @@ Honour `yas-dont-activate', which see."
(defun yas--populate-template (template &rest args)
"Helper function to populate TEMPLATE with properties."
- (let (p v)
- (while args
- (aset template
- (position (intern (substring (symbol-name (car args)) 1))
- (mapcar #'car (get 'yas--template 'cl-struct-slots)))
- (second args))
- (setq args (cddr args)))
- template))
+ (while args
+ (aset template
+ (position (intern (substring (symbol-name (car args)) 1))
+ (mapcar #'car (get 'yas--template 'cl-struct-slots)))
+ (second args))
+ (setq args (cddr args)))
+ template)
(defstruct (yas--table (:constructor yas--make-snippet-table (name)))
"A table to store snippets for a particular mode.
@@ -916,8 +911,7 @@ Has the following fields:
`yas--table-uuidhash'
A hash table mapping snippets uuid's to the same `yas--template'
- objects. A snippet uuid defaults to the snippet's name.
-"
+ objects. A snippet uuid defaults to the snippet's name."
name
(hash (make-hash-table :test 'equal))
(uuidhash (make-hash-table :test 'equal))
@@ -1019,7 +1013,7 @@ keybinding)."
(let ((name (yas--template-name template))
(key (yas--template-key template))
(keybinding (yas--template-keybinding template))
- (menu-binding-pair (yas--template-menu-binding-pair-get-create
template)))
+ (_menu-binding-pair (yas--template-menu-binding-pair-get-create
template)))
(dolist (k (remove nil (list key keybinding)))
(puthash name
template
@@ -1144,7 +1138,7 @@ This function implements the rules described in
templates))))
(defun yas--require-template-specific-condition-p ()
- "Decides if this buffer requests/requires snippet-specific
+ "Decide if this buffer requests/requires snippet-specific
conditions to filter out potential expansions."
(if (eq 'always yas-buffer-local-condition)
'always
@@ -1160,7 +1154,7 @@ conditions to filter out potential expansions."
(cdr local-condition)))))))
(defun yas--template-can-expand-p (condition requirement)
- "Evaluates CONDITION and REQUIREMENT and returns a boolean."
+ "Evaluate CONDITION and REQUIREMENT and return a boolean."
(let* ((result (or (null condition)
(yas--eval-condition condition))))
(cond ((eq requirement t)
@@ -1169,7 +1163,7 @@ conditions to filter out potential expansions."
(eq requirement result)))))
(defun yas--all-parents (mode)
- "Returns a list of all parent modes of MODE."
+ "Return a list of all parent modes of MODE."
(or (gethash mode yas--ancestors)
(let ((seen '()))
(labels ((yas--all-parents-1
@@ -1189,7 +1183,7 @@ conditions to filter out potential expansions."
(defun yas--table-templates (table)
(when table
(let ((acc (list)))
- (maphash #'(lambda (key namehash)
+ (maphash #'(lambda (_key namehash)
(maphash #'(lambda (name template)
(push (cons name template) acc))
namehash))
@@ -1197,8 +1191,8 @@ conditions to filter out potential expansions."
(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."
+ "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)
@@ -1329,8 +1323,8 @@ ensure your use `make-local-variable' when you set it.")
Return a list of `yas--table' objects. The list of modes to
consider is returned by `yas--modes-to-activate'"
(remove nil
- (mapcar #'(lambda (mode-name)
- (gethash mode-name yas--tables))
+ (mapcar #'(lambda (name)
+ (gethash name yas--tables))
(yas--modes-to-activate))))
(defun yas--menu-keymap-get-create (mode &optional parents)
@@ -1356,43 +1350,6 @@ in GNU Emacs 24.1 or higher."
'(called-interactively-p)
`(called-interactively-p ,kind)))
-
-(defun yas--call-with-temporary-redefinitions (function
- &rest
function-names-and-overriding-functions)
- (let* ((overrides (remove-if-not #'(lambda (fdef)
- (fboundp (first fdef)))
- function-names-and-overriding-functions))
- (definition-names (mapcar #'first overrides))
- (overriding-functions (mapcar #'second overrides))
- (saved-functions (mapcar #'symbol-function definition-names)))
- ;; saving all definitions before overriding anything ensures FDEFINITION
- ;; errors don't cause accidental permanent redefinitions.
- ;;
- (labels ((set-fdefinitions (names functions)
- (loop for name in names
- for fn in functions
- do (fset name fn))))
- (set-fdefinitions definition-names overriding-functions)
- (unwind-protect (funcall function)
- (set-fdefinitions definition-names saved-functions)))))
-
-
-(defmacro yas--with-temporary-redefinitions (fdefinitions &rest body)
- ;; "Temporarily (but globally) redefine each function in FDEFINITIONS.
- ;; E.g.: (yas--with-temporary-redefinitions ((foo (x) ...)
- ;; (bar (x) ...))
- ;; ;; code that eventually calls foo, bar of (setf foo)
- ;; ...)"
- `(yas--call-with-temporary-redefinitions
- (lambda () ,@body)
- ,@(mapcar #'(lambda (thingy)
- `(list ',(first thingy)
- (lambda ,@(rest thingy))))
- fdefinitions)))
-
-(put 'yas--with-temporary-redefinitions 'lisp-indent-function 1)
-(put 'yas--with-temporary-redefinitions 'edebug-form-spec '((&rest (defun*))
cl-declarations body))
-
;;; Template-related and snippet loading functions
@@ -1641,12 +1598,8 @@ Optional PROMPT sets the prompt to use."
ido-mode))
(yas-completing-prompt prompt choices display-fn #'ido-completing-read)))
-(eval-when-compile
- (if (fboundp 'declare-function)
- (declare-function dropdown-list "dropdown-list")))
-
-(defun yas-dropdown-prompt (prompt choices &optional display-fn)
- (when (featurep 'dropdown-list)
+(defun yas-dropdown-prompt (_prompt choices &optional display-fn)
+ (when (fboundp 'dropdown-list)
(let (formatted-choices
filtered-choices
d
@@ -1688,7 +1641,7 @@ Optional PROMPT sets the prompt to use."
0)))
(nth position filtered-choices))))
-(defun yas-no-prompt (prompt choices &optional display-fn)
+(defun yas-no-prompt (_prompt choices &optional _display-fn)
(first choices))
@@ -1697,6 +1650,8 @@ Optional PROMPT sets the prompt to use."
;; correct tables.
;;
+(defvar yas--creating-compiled-snippets nil)
+
(defun yas--define-snippets-1 (snippet snippet-table)
"Helper for `yas-define-snippets'."
;; X) Calculate some more defaults on the values returned by
@@ -1747,10 +1702,10 @@ following form
Within these, only KEY and TEMPLATE are actually mandatory.
-TEMPLATE might be a lisp form or a string, depending on whether
+TEMPLATE might be a Lisp form or a string, depending on whether
this is a snippet or a snippet-command.
-CONDITION, EXPAND-ENV and KEYBINDING are lisp forms, they have
+CONDITION, EXPAND-ENV and KEYBINDING are Lisp forms, they have
been `yas--read-lisp'-ed and will eventually be
`yas--eval-lisp'-ed.
@@ -1764,18 +1719,54 @@ with the same uuid replaced the previous snippet.
You can use `yas--parse-template' to return such lists based on
the current buffers contents."
- (let ((snippet-table (yas--table-get-create mode))
- (template nil))
- (dolist (snippet snippets)
- (setq template (yas--define-snippets-1 snippet
- snippet-table)))
- template))
+ (if yas--creating-compiled-snippets
+ (progn
+ (insert ";;; Snippet definitions:\n;;;\n")
+ (let ((literal-snippets (list))
+ (print-length nil))
+ (dolist (snippet snippets)
+ (let ((key (nth 0 snippet))
+ (template-content (nth 1 snippet))
+ (name (nth 2 snippet))
+ (condition (nth 3 snippet))
+ (group (nth 4 snippet))
+ (expand-env (nth 5 snippet))
+ (file nil) ;; omit on purpose
+ (binding (nth 7 snippet))
+ (uuid (nth 8 snippet)))
+ (push `(,key
+ ,template-content
+ ,name
+ ,condition
+ ,group
+ ,expand-env
+ ,file
+ ,binding
+ ,uuid)
+ literal-snippets)))
+ (insert (pp-to-string
+ `(yas-define-snippets ',mode ',literal-snippets)))
+ (insert "\n\n")))
+ ;; Normal case.
+ (let ((snippet-table (yas--table-get-create mode))
+ (template nil))
+ (dolist (snippet snippets)
+ (setq template (yas--define-snippets-1 snippet
+ snippet-table)))
+ template)))
;;; Loading snippets from files
(defun yas--load-yas-setup-file (file)
- (load file 'noerror))
+ (if (not yas--creating-compiled-snippets)
+ ;; Normal case.
+ (load file 'noerror)
+ (let ((elfile (concat file ".el")))
+ (when (file-exists-p elfile)
+ (insert ";;; .yas-setup.el support file if any:\n;;;\n")
+ (insert-file-contents elfile)
+ (goto-char (point-max))))))
(defun yas--define-parents (mode parents)
"Add PARENTS to the list of MODE's parents."
@@ -1784,13 +1775,13 @@ the current buffers contents."
(gethash mode yas--parents)))
yas--parents))
-(defun yas-load-directory (top-level-dir &optional use-jit)
+(defun yas-load-directory (top-level-dir &optional use-jit interactive)
"Load snippets in directory hierarchy TOP-LEVEL-DIR.
Below TOP-LEVEL-DIR each directory should be a mode name.
Optional USE-JIT use jit-loading of snippets."
- (interactive "DSelect the root directory: ")
+ (interactive "DSelect the root directory: ni\np")
(unless yas-snippet-dirs
(setq yas-snippet-dirs top-level-dir))
(dolist (dir (yas--subdirs top-level-dir))
@@ -1811,29 +1802,38 @@ Optional USE-JIT use jit-loading of snippets."
;;
(yas--define-parents mode-sym parents)
(yas--menu-keymap-get-create mode-sym)
- (let ((form `(yas--load-directory-1 ,dir
- ',mode-sym
- ',parents)))
+ (let ((fun `(lambda () ;; FIXME: Simulating lexical-binding.
+ (yas--load-directory-1 ',dir ',mode-sym))))
(if (and use-jit
(not (some #'(lambda (buffer)
(with-current-buffer buffer
+ ;; FIXME: Shouldn't this use derived-mode-p?
(when (eq major-mode mode-sym)
(yas--message 3 "Discovered there was
already %s in %s" buffer mode-sym)
t)))
(buffer-list))))
- (yas--schedule-jit mode-sym form)
- (eval form)))))
- (when (yas--called-interactively-p 'interactive)
+ (yas--schedule-jit mode-sym fun)
+ (funcall fun)))))
+ (when interactive
(yas--message 3 "Loaded snippets from %s." top-level-dir)))
-(defun yas--load-directory-1 (directory mode-sym parents &optional
no-compiled-snippets)
+(defun yas--load-directory-1 (directory mode-sym)
"Recursively load snippet templates from DIRECTORY."
- (unless (file-exists-p (concat directory "/" ".yas-skip"))
- (if (and (not no-compiled-snippets)
- (progn (yas--message 2 "Loading compiled snippets from %s"
directory) t)
- (load (expand-file-name ".yas-compiled-snippets" directory)
'noerror (<= yas-verbosity 3)))
- (yas--message 2 "Loading snippet files from %s" directory)
- (yas--load-directory-2 directory mode-sym))))
+ (if yas--creating-compiled-snippets
+ (let ((output-file (expand-file-name ".yas-compiled-snippets.el"
+ directory)))
+ (with-temp-file output-file
+ (insert (format ";;; Compiled snippets and support files for `%s'\n"
+ mode-sym))
+ (yas--load-directory-2 directory mode-sym)
+ (insert (format ";;; Do not edit! File generated at %s\n"
+ (current-time-string)))))
+ ;; Normal case.
+ (unless (file-exists-p (concat directory "/" ".yas-skip"))
+ (if (and (progn (yas--message 2 "Loading compiled snippets from %s"
directory) t)
+ (load (expand-file-name ".yas-compiled-snippets" directory)
'noerror (<= yas-verbosity 3)))
+ (yas--message 2 "Loading snippet files from %s" directory)
+ (yas--load-directory-2 directory mode-sym)))))
(defun yas--load-directory-2 (directory mode-sym)
;; Load .yas-setup.el files wherever we find them
@@ -1898,7 +1898,10 @@ loading."
(throw 'abort nil))
;; in a non-interactive use, at least set
;; `yas--editing-template' to nil, make it guess it next time
around
- (mapc #'(lambda (buffer) (setq yas--editing-template nil))
(buffer-list))))
+ (mapc #'(lambda (buffer)
+ (with-current-buffer buffer
+ (kill-local-variable 'yas--editing-template)))
+ (buffer-list))))
;; Empty all snippet tables and parenting info
;;
@@ -1910,7 +1913,7 @@ loading."
;; mode menu parts of `yas--minor-mode-menu' (thus also cleaning
;; up `yas-minor-mode-map', which points to it)
;;
- (maphash #'(lambda (menu-symbol keymap)
+ (maphash #'(lambda (menu-symbol _keymap)
(define-key yas--minor-mode-menu (vector menu-symbol) nil))
yas--menu-table)
;; Now empty `yas--menu-table' as well
@@ -1934,11 +1937,11 @@ loading."
(defun yas--load-pending-jits ()
(dolist (mode (yas--modes-to-activate))
- (let ((forms (reverse (gethash mode yas--scheduled-jit-loads))))
+ (let ((funs (reverse (gethash mode yas--scheduled-jit-loads))))
;; must reverse to maintain coherence with `yas-snippet-dirs'
- (dolist (form forms)
- (yas--message 3 "Loading for `%s', just-in-time: %s!" mode form)
- (eval form))
+ (dolist (fun funs)
+ (yas--message 3 "Loading for `%s', just-in-time: %s!" mode fun)
+ (funcall fun))
(remhash mode yas--scheduled-jit-loads))))
;; (when (<= emacs-major-version 22)
@@ -1966,50 +1969,8 @@ foo\"bar\\! -> \"foo\\\"bar\\\\!\""
This works by stubbing a few functions, then calling
`yas-load-directory'."
(interactive "DTop level snippet directory?")
- (yas--with-temporary-redefinitions
- ((yas--load-yas-setup-file
- (file)
- (let ((elfile (concat file ".el")))
- (when (file-exists-p elfile)
- (insert ";;; .yas-setup.el support file if any:\n;;;\n")
- (insert-file-contents elfile)
- (goto-char (point-max))
- )))
- (yas-define-snippets
- (mode snippets)
- (insert ";;; Snippet definitions:\n;;;\n")
- (let ((literal-snippets (list))
- (print-length nil))
- (dolist (snippet snippets)
- (let ((key (first snippet))
- (template-content (second snippet))
- (name (third snippet))
- (condition (fourth snippet))
- (group (fifth snippet))
- (expand-env (sixth snippet))
- (file nil) ;; (seventh snippet)) ;; omit on
purpose
- (binding (eighth snippet))
- (uuid (ninth snippet)))
- (push `(,key
- ,template-content
- ,name
- ,condition
- ,group
- ,expand-env
- ,file
- ,binding
- ,uuid)
- literal-snippets)))
- (insert (pp-to-string `(yas-define-snippets ',mode ',literal-snippets)))
- (insert "\n\n")))
- (yas--load-directory-1
- (dir mode parents &rest ignore)
- (let ((output-file (concat (file-name-as-directory dir)
".yas-compiled-snippets.el")))
- (with-temp-file output-file
- (insert (format ";;; Compiled snippets and support files for `%s'\n"
mode))
- (yas--load-directory-2 dir mode)
- (insert (format ";;; Do not edit! File generated at %s\n"
(current-time-string)))))))
- (yas-load-directory top-level-dir nil)))
+ (let ((yas--creating-compiled-snippets t))
+ (yas-load-directory top-level-dir nil)))
(defun yas-recompile-all ()
"Compile every dir in `yas-snippet-dirs'."
@@ -2023,11 +1984,8 @@ This works by stubbing a few functions, then calling
(defvar yas--scheduled-jit-loads (make-hash-table)
"Alist of mode-symbols to forms to be evaled when `yas-minor-mode' kicks
in.")
-(defun yas--schedule-jit (mode form)
- (puthash mode
- (cons form
- (gethash mode yas--scheduled-jit-loads))
- yas--scheduled-jit-loads))
+(defun yas--schedule-jit (mode fun)
+ (push fun (gethash mode yas--scheduled-jit-loads)))
@@ -2077,8 +2035,9 @@ This works by stubbing a few functions, then calling
TYPE may be `:stay', signaling this menu binding should be
static in the menu."
(or (yas--template-menu-binding-pair template)
- (let ((key (yas--template-key template))
- (keybinding (yas--template-keybinding template)))
+ (let (;; (key (yas--template-key template))
+ ;; (keybinding (yas--template-keybinding template))
+ )
(setf (yas--template-menu-binding-pair template)
(cons `(menu-item ,(or (yas--template-name template)
(yas--template-uuid template))
@@ -2218,8 +2177,8 @@ Just put this function in
`hippie-expand-try-functions-list'."
;;;
(defvar yas--condition-cache-timestamp nil)
(defmacro yas-define-condition-cache (func doc &rest body)
- "Define a function FUNC with doc DOC and body BODY, BODY is
-executed at most once every snippet expansion attempt, to check
+ "Define a function FUNC with doc DOC and body BODY.
+BODY is executed at most once every snippet expansion attempt, to check
expansion conditions.
It doesn't make any sense to call FUNC programatically."
@@ -2265,7 +2224,7 @@ object satisfying `yas--field-p' to restrict the
expansion to."
(yas--expand-or-prompt-for-template (first templates-and-pos)
(second templates-and-pos)
(third templates-and-pos))
- (yas--fallback 'trigger-key))))
+ (yas--fallback))))
(defun yas-expand-from-keymap ()
"Directly expand some snippets, searching `yas--direct-keymaps'.
@@ -2273,8 +2232,7 @@ object satisfying `yas--field-p' to restrict the
expansion to."
If expansion fails, execute the previous binding for this key"
(interactive)
(setq yas--condition-cache-timestamp (current-time))
- (let* ((yas--prefix current-prefix-arg)
- (vec (subseq (this-command-keys-vector) (if current-prefix-arg
+ (let* ((vec (subseq (this-command-keys-vector) (if current-prefix-arg
universal-argument-num-events
0)))
(templates (mapcan #'(lambda (table)
@@ -2307,7 +2265,7 @@ expand immediately. Common gateway for
;; returns `org-cycle'. However, most other modes bind "TAB". TODO,
;; improve this explanation.
;;
-(defun yas--fallback (&optional from-trigger-key-p)
+(defun yas--fallback ()
"Fallback after expansion has failed.
Common gateway for `yas-expand-from-trigger-key' and
@@ -2335,7 +2293,7 @@ Common gateway for `yas-expand-from-trigger-key' and
nil)))
(defun yas--keybinding-beyond-yasnippet ()
- "Returns the "
+ "Return the ??"
(let* ((yas-minor-mode nil)
(yas--direct-keymaps nil)
(keys (this-single-command-keys)))
@@ -2345,8 +2303,8 @@ Common gateway for `yas-expand-from-trigger-key' and
(defun yas--fallback-translate-input (keys)
"Emulate `read-key-sequence', at least what I think it does.
-Keys should be an untranslated key vector. Returns a translated
-vector of keys. FIXME not thoroughly tested"
+Keys should be an untranslated key vector. Returns a translated
+vector of keys. FIXME not thoroughly tested."
(let ((retval [])
(i 0))
(while (< i (length keys))
@@ -2462,7 +2420,7 @@ visited file in `snippet-mode'."
(set (make-local-variable 'yas--editing-template) template)))))
(defun yas--guess-snippet-directories-1 (table)
- "Guesses possible snippet subdirectories for TABLE."
+ "Guess possible snippet subdirectories for TABLE."
(cons (yas--table-name table)
(mapcan #'(lambda (parent)
(yas--guess-snippet-directories-1
@@ -2497,7 +2455,7 @@ where snippets of table might exist."
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."
+ "Return 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))))
(unless (file-writable-p (file-name-directory candidate))
@@ -2706,7 +2664,7 @@ whether (and where) to save the snippet, then quit the
window."
(buffer (get-buffer-create "*YASnippet tables*"))
(active-tables (yas--get-snippet-tables))
(remain-tables (let ((all))
- (maphash #'(lambda (k v)
+ (maphash #'(lambda (_k v)
(unless (find v active-tables)
(push v all)))
yas--tables)
@@ -2737,13 +2695,13 @@ whether (and where) to save the snippet, then quit the
window."
(dolist (table (append active-tables remain-tables))
(insert (format "\nSnippet table `%s':\n\n" (yas--table-name
table)))
(let ((keys))
- (maphash #'(lambda (k v)
+ (maphash #'(lambda (k _v)
(push k keys))
(yas--table-hash table))
(dolist (key keys)
(insert (format " key %s maps snippets: %s\n" key
(let ((names))
- (maphash #'(lambda (k v)
+ (maphash #'(lambda (k _v)
(push k names))
(gethash key (yas--table-hash
table)))
names))))))))
@@ -2762,7 +2720,7 @@ whether (and where) to save the snippet, then quit the
window."
(insert (make-string 100 ?-) "\n")
(insert "group state name
key binding\n")
(let ((groups-hash (make-hash-table :test #'equal)))
- (maphash #'(lambda (k v)
+ (maphash #'(lambda (_k v)
(let ((group (or (yas--template-fine-group v)
"(top level)")))
(when (yas--template-name v)
@@ -2912,9 +2870,6 @@ Use this in primary and mirror transformations to tget."
(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-selected-text nil
"The selected region deleted on the last snippet expansion.")
@@ -2986,7 +2941,6 @@ If there is no transform for ht field, return nil.
If there is a transform but it returns nil, return the empty
string iff EMPTY-ON-NIL-P is true."
(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)
@@ -3110,7 +3064,6 @@ If there's none, exit the snippet."
(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--eval-lisp (yas--field-transform active-field))))
@@ -3146,7 +3099,7 @@ Also create some protection overlays"
(setf (yas--snippet-active-field snippet) field)
;; primary field transform: first call to snippet transform
(unless (yas--field-modified-p field)
- (if (yas--field-update-display field snippet)
+ (if (yas--field-update-display field)
(yas--update-mirrors snippet)
(setf (yas--field-modified-p field) nil))))))
@@ -3182,11 +3135,14 @@ Also create some protection overlays"
;;; Some low level snippet-routines:
+(defvar yas--inhibit-overlay-hooks nil
+ "Bind this temporarily to non-nil to prevent running
`yas--on-*-modification'.")
+
(defmacro yas--inhibit-overlay-hooks (&rest body)
"Run BODY with `yas--inhibit-overlay-hooks' set to t."
(declare (indent 0))
`(let ((yas--inhibit-overlay-hooks t))
- (progn ,@body)))
+ ,@body))
(defvar yas-snippet-beg nil "Beginning position of the last snippet
committed.")
(defvar yas-snippet-end nil "End position of the last snippet committed.")
@@ -3244,7 +3200,7 @@ This renders the snippet as ordinary text."
(defun yas--check-commit-snippet ()
- "Checks if point exited the currently active field of the snippet.
+ "Check 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))
@@ -3348,7 +3304,7 @@ This is done by setting MARKER to POINT with
`set-marker'."
(eq this-command 'redo)))
(defun yas--make-control-overlay (snippet start end)
- "Creates the control overlay that surrounds the snippet and
+ "Create the control overlay that surrounds the snippet and
holds the keymap."
(let ((overlay (make-overlay start
end
@@ -3419,24 +3375,20 @@ Move the overlay, or create it if it does not exit."
(overlay-put yas--active-field-overlay 'insert-behind-hooks
'(yas--on-field-overlay-modification))))
-(defvar yas--inhibit-overlay-hooks nil
- "Bind this temporarily to non-nil to prevent running
`yas--on-*-modification'.")
-
-(defun yas--on-field-overlay-modification (overlay after? beg end &optional
length)
+(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
+at field start. This hook doesn't do anything if an undo is in
progress."
(unless (or yas--inhibit-overlay-hooks
(yas--undo-in-progress))
(let* ((field (overlay-get overlay 'yas--field))
- (number (and field (yas--field-number field)))
(snippet (overlay-get yas--active-field-overlay 'yas--snippet)))
(cond (after?
(yas--advance-end-maybe field (overlay-end overlay))
(save-excursion
- (yas--field-update-display field snippet))
+ (yas--field-update-display field))
(yas--update-mirrors snippet))
(field
(when (and (not after?)
@@ -3504,7 +3456,7 @@ Functions in the `post-command-hook', for example
nil. The variables value is the point where the violation
originated")
-(defun yas--on-protection-overlay-modification (overlay after? beg end
&optional length)
+(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'"
@@ -3602,9 +3554,9 @@ considered when expanding the snippet."
(if expand-env
(eval `(let* ,expand-env
(insert content)
- (yas--snippet-create (point-min)
(point-max))))
+ (yas--snippet-create (point-min))))
(insert content)
- (yas--snippet-create (point-min) (point-max)))))))
+ (yas--snippet-create (point-min)))))))
;; stacked-expansion: This checks for stacked expansion, save the
;; `yas--previous-active-field' and advance its boundary.
@@ -3647,7 +3599,7 @@ considered when expanding the snippet."
(yas--message 3 "snippet expanded.")
t))))
-(defun yas--take-care-of-redo (beg end snippet)
+(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'."
@@ -3659,8 +3611,8 @@ Meant to exit in the `buffer-undo-list'."
(defun yas--snippet-revive (beg end snippet)
"Revives SNIPPET and creates a control overlay from BEG to END.
-BEG and END are, we hope, the original snippets boundaries. All
-the markers/points exiting existing inside SNIPPET should point
+BEG and END are, we hope, the original snippets boundaries.
+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
@@ -3682,8 +3634,8 @@ After revival, push the `yas--take-care-of-redo' in the
(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.
+(defun yas--snippet-create (begin)
+ "Create a snippet from a template inserted at BEGIN.
Returns the newly created snippet."
(let ((snippet (yas--make-snippet)))
@@ -3758,19 +3710,20 @@ Returns the newly created snippet."
This is according to their relative positions in the buffer, and
has to be called before the $-constructs are deleted."
- (labels ((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)
- (if (= (yas--fom-start fom2) (yas--fom-start
fom1))
- (yas--mirror-p fom2)
- (>= (yas--fom-start fom2) (yas--fom-start
fom1))))
- (yas--link-foms (fom1 fom2)
- (yas--fom-set-next-fom fom1 fom2)))
+ (let* ((fom-set-next-fom
+ (lambda (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)))))
+ (compare-fom-begs
+ (lambda (fom1 fom2)
+ (if (= (yas--fom-start fom2) (yas--fom-start fom1))
+ (yas--mirror-p fom2)
+ (>= (yas--fom-start fom2) (yas--fom-start fom1)))))
+ (link-foms fom-set-next-fom))
;; make some yas--field, yas--mirror and yas--exit soup
(let ((soup))
(when (yas--snippet-exit snippet)
@@ -3780,10 +3733,9 @@ has to be called before the $-constructs are deleted."
(dolist (mirror (yas--field-mirrors field))
(push mirror soup)))
(setq soup
- (sort soup
- #'yas--compare-fom-begs))
+ (sort soup compare-fom-begs))
(when soup
- (reduce #'yas--link-foms soup)))))
+ (reduce link-foms soup)))))
(defun yas--calculate-mirrors-in-fields (snippet mirror)
"Attempt to assign a parent field of SNIPPET to the mirror MIRROR.
@@ -3834,7 +3786,7 @@ If it does, also call `yas--advance-end-maybe' on FOM."
"Like `yas--advance-end-maybe' but for parent fields.
Only works for fields and doesn't care about the start of the
-next FOM. Works its way up recursively for parents of parents."
+next FOM. Works its way up recursively for parents of parents."
(when (and field
(< (yas--field-end field) newend))
(set-marker (yas--field-end field) newend)
@@ -3846,7 +3798,7 @@ cons cells to this var.")
(defvar yas--backquote-markers-and-strings nil
"List of (MARKER . STRING) marking where the values from
-backquoted lisp expressions should be inserted at the end of
+backquoted Lisp expressions should be inserted at the end of
expansion.")
(defun yas--snippet-parse-create (snippet)
@@ -3927,7 +3879,7 @@ Meant to be called in a narrowed buffer, does various
passes"
snippet-markers)))
(save-restriction
(widen)
- (condition-case err
+ (condition-case _
(indent-according-to-mode)
(error (yas--message 3 "Warning: `yas--indent-according-to-mode'
having problems running %s" indent-line-function)
nil)))
@@ -4048,7 +4000,7 @@ with their evaluated value into
`yas--backquote-markers-and-strings'."
(set-marker marker nil)))))
(defun yas--scan-sexps (from count)
- (condition-case err
+ (condition-case _
(with-syntax-table (standard-syntax-table)
(scan-sexps from count))
(error
@@ -4067,7 +4019,7 @@ 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;
+* \"${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.
@@ -4225,7 +4177,7 @@ When multiple expressions are found, only the last one
counts."
0))))))
(defun yas--update-mirrors (snippet)
- "Updates all the mirrors of SNIPPET."
+ "Update all the mirrors of SNIPPET."
(save-excursion
(dolist (field-and-mirror (sort
;; make a list of ((F1 . M1) (F1 . M2) (F2 .
M3) (F2 . M4) ...)
@@ -4283,12 +4235,11 @@ When multiple expressions are found, only the last one
counts."
;; super-special advance
(yas--advance-end-of-parents-maybe mirror-parent-field (point))))))
-(defun yas--field-update-display (field snippet)
+(defun yas--field-update-display (field)
"Much like `yas--mirror-update-display', but for fields."
(when (yas--field-transform field)
(let ((transformed (and (not (eq (yas--field-number field) 0))
- (yas--apply-transform field field)))
- (point (point)))
+ (yas--apply-transform field field))))
(when (and transformed
(not (string= transformed (buffer-substring-no-properties
(yas--field-start field)
(yas--field-end field)))))
@@ -4404,16 +4355,6 @@ object satisfying `yas--field-p' to restrict the
expansion to.")))
(help-xref-button 1 'help-snippet-def template)
(kill-region (match-end 1) (match-end 0))
(kill-region (match-beginning 0) (match-beginning 1)))))))
-
-(defun yas--expand-uuid (mode-symbol uuid &optional start end expand-env)
- "Expand a snippet registered in MODE-SYMBOL's table with UUID.
-
-Remaining args as in `yas-expand-snippet'."
- (let* ((table (gethash mode-symbol yas--tables))
- (yas--current-template (and table
- (gethash uuid (yas--table-uuidhash
table)))))
- (when yas--current-template
- (yas-expand-snippet (yas--template-content yas--current-template)))))
;;; Utils
@@ -4464,11 +4405,6 @@ and return the directory. Return nil if not found."
;; `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 UUID".
- (user nil)
try)
(while (not (or root
(null file)
@@ -4485,8 +4421,7 @@ and return the directory. Return nil if not found."
(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
+ ((equal file (setq file (file-name-directory
(directory-file-name file))))
(setq file nil))))
root))))
@@ -4506,7 +4441,7 @@ and return the directory. Return nil if not found."
(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
+handle the `end-of-buffer' error fired in it by calling
`forward-char' at the end of buffer."
(condition-case err
ad-do-it
-----------------------------------------------------------------------
Summary of changes:
packages/yasnippet/yasnippet-tests.el | 50 ++++-
packages/yasnippet/yasnippet.el | 437 ++++++++++++++-------------------
2 files changed, 228 insertions(+), 259 deletions(-)
hooks/post-receive
--
ELPA
| [Prev in Thread] |
Current Thread |
[Next in Thread] |
- [ELPA-diffs] ELPA branch, master, updated. a8eda6e7dfd43b448119fd3b607dc6c5c9af5c5c,
Stefan Monnier <=