Update packages

elpa/helm-20161016.827/helm-autoloads.el

@@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
 
-;;;### (autoloads nil "helm-adaptive" "helm-adaptive.el" (22527 12706
+;;;### (autoloads nil "helm-adaptive" "helm-adaptive.el" (22532 34656
-;;;;;;  658693 982000))
+;;;;;;  132334 628000))
 ;;; Generated autoloads from helm-adaptive.el
 
 (defvar helm-adaptive-mode nil "\
@@ -30,8 +30,8 @@ Useful when you have a old or corrupted `helm-adaptive-history-file'.
 
 ;;;***
 
-;;;### (autoloads nil "helm-apt" "helm-apt.el" (22527 12706 618693
+;;;### (autoloads nil "helm-apt" "helm-apt.el" (22532 34656 96334
-;;;;;;  945000))
+;;;;;;  318000))
 ;;; Generated autoloads from helm-apt.el
 
 (autoload 'helm-apt "helm-apt" "\
@@ -42,8 +42,8 @@ With a prefix arg reload cache.
 
 ;;;***
 
-;;;### (autoloads nil "helm-bookmark" "helm-bookmark.el" (22527 12706
+;;;### (autoloads nil "helm-bookmark" "helm-bookmark.el" (22532 34656
-;;;;;;  706694 27000))
+;;;;;;  188335 110000))
 ;;; Generated autoloads from helm-bookmark.el
 
 (autoload 'helm-bookmarks "helm-bookmark" "\
@@ -60,8 +60,8 @@ only if external library addressbook-bookmark.el is available.
 
 ;;;***
 
-;;;### (autoloads nil "helm-buffers" "helm-buffers.el" (22527 12706
+;;;### (autoloads nil "helm-buffers" "helm-buffers.el" (22532 34656
-;;;;;;  606693 934000))
+;;;;;;  80334 181000))
 ;;; Generated autoloads from helm-buffers.el
 
 (autoload 'helm-buffers-list "helm-buffers" "\
@@ -76,8 +76,8 @@ Preconfigured `helm' lightweight version (buffer -> recentf).
 
 ;;;***
 
-;;;### (autoloads nil "helm-color" "helm-color.el" (22527 12706 686694
+;;;### (autoloads nil "helm-color" "helm-color.el" (22532 34656 168334
-;;;;;;  9000))
+;;;;;;  938000))
 ;;; Generated autoloads from helm-color.el
 
 (autoload 'helm-colors "helm-color" "\
@@ -87,8 +87,8 @@ Preconfigured `helm' for color.
 
 ;;;***
 
-;;;### (autoloads nil "helm-command" "helm-command.el" (22527 12706
+;;;### (autoloads nil "helm-command" "helm-command.el" (22532 34656
-;;;;;;  550693 880000))
+;;;;;;  32333 769000))
 ;;; Generated autoloads from helm-command.el
 
 (autoload 'helm-M-x "helm-command" "\
@@ -106,8 +106,8 @@ You can get help on each command by persistent action.
 
 ;;;***
 
-;;;### (autoloads nil "helm-config" "helm-config.el" (22527 12706
+;;;### (autoloads nil "helm-config" "helm-config.el" (22532 34656
-;;;;;;  702694 24000))
+;;;;;;  184335 76000))
 ;;; Generated autoloads from helm-config.el
 
 (autoload 'helm-configuration "helm-config" "\
@@ -117,8 +117,8 @@ Customize `helm'.
 
 ;;;***
 
-;;;### (autoloads nil "helm-dabbrev" "helm-dabbrev.el" (22527 12706
+;;;### (autoloads nil "helm-dabbrev" "helm-dabbrev.el" (22532 34656
-;;;;;;  630693 956000))
+;;;;;;  112334 456000))
 ;;; Generated autoloads from helm-dabbrev.el
 
 (autoload 'helm-dabbrev "helm-dabbrev" "\
@@ -128,8 +128,8 @@ Preconfigured helm for dynamic abbreviations.
 
 ;;;***
 
-;;;### (autoloads nil "helm-elisp" "helm-elisp.el" (22527 12706 694694
+;;;### (autoloads nil "helm-elisp" "helm-elisp.el" (22532 34656 176335
-;;;;;;  16000))
+;;;;;;  6000))
 ;;; Generated autoloads from helm-elisp.el
 
 (autoload 'helm-lisp-completion-at-point "helm-elisp" "\
@@ -183,7 +183,7 @@ Preconfigured helm for complex command history.
 ;;;***
 
 ;;;### (autoloads nil "helm-elisp-package" "helm-elisp-package.el"
-;;;;;;  (22527 12706 562693 892000))
+;;;;;;  (22532 34656 36333 804000))
 ;;; Generated autoloads from helm-elisp-package.el
 
 (autoload 'helm-list-elisp-packages "helm-elisp-package" "\
@@ -199,8 +199,8 @@ Same as `helm-list-elisp-packages' but don't fetch packages on remote.
 
 ;;;***
 
-;;;### (autoloads nil "helm-elscreen" "helm-elscreen.el" (22527 12706
+;;;### (autoloads nil "helm-elscreen" "helm-elscreen.el" (22532 34656
-;;;;;;  538693 870000))
+;;;;;;  24333 700000))
 ;;; Generated autoloads from helm-elscreen.el
 
 (autoload 'helm-elscreen "helm-elscreen" "\
@@ -215,8 +215,8 @@ Preconfigured helm to list elscreen in history order.
 
 ;;;***
 
-;;;### (autoloads nil "helm-eshell" "helm-eshell.el" (22527 12706
+;;;### (autoloads nil "helm-eshell" "helm-eshell.el" (22532 34656
-;;;;;;  578693 906000))
+;;;;;;  56333 975000))
 ;;; Generated autoloads from helm-eshell.el
 
 (autoload 'helm-esh-pcomplete "helm-eshell" "\
@@ -231,8 +231,8 @@ Preconfigured helm for eshell history.
 
 ;;;***
 
-;;;### (autoloads nil "helm-eval" "helm-eval.el" (22527 12706 662693
+;;;### (autoloads nil "helm-eval" "helm-eval.el" (22532 34656 140334
-;;;;;;  986000))
+;;;;;;  698000))
 ;;; Generated autoloads from helm-eval.el
 
 (autoload 'helm-eval-expression "helm-eval" "\
@@ -252,8 +252,8 @@ Preconfigured helm for `helm-source-calculation-result'.
 
 ;;;***
 
-;;;### (autoloads nil "helm-external" "helm-external.el" (22527 12706
+;;;### (autoloads nil "helm-external" "helm-external.el" (22532 34656
-;;;;;;  530693 861000))
+;;;;;;  12333 596000))
 ;;; Generated autoloads from helm-external.el
 
 (autoload 'helm-run-external-command "helm-external" "\
@@ -266,8 +266,8 @@ You can set your own list of commands with
 
 ;;;***
 
-;;;### (autoloads nil "helm-files" "helm-files.el" (22527 12706 638693
+;;;### (autoloads nil "helm-files" "helm-files.el" (22532 34656 116334
-;;;;;;  964000))
+;;;;;;  491000))
 ;;; Generated autoloads from helm-files.el
 
 (autoload 'helm-projects-history "helm-files" "\
@@ -355,8 +355,8 @@ It allows additionally to delete more than one connection at once.
 
 ;;;***
 
-;;;### (autoloads nil "helm-font" "helm-font.el" (22527 12706 582693
+;;;### (autoloads nil "helm-font" "helm-font.el" (22532 34656 60334
-;;;;;;  910000))
+;;;;;;  9000))
 ;;; Generated autoloads from helm-font.el
 
 (autoload 'helm-select-xfont "helm-font" "\
@@ -371,8 +371,8 @@ Preconfigured helm for `ucs-names' math symbols.
 
 ;;;***
 
-;;;### (autoloads nil "helm-grep" "helm-grep.el" (22527 12706 710694
+;;;### (autoloads nil "helm-grep" "helm-grep.el" (22532 34656 192335
-;;;;;;  32000))
+;;;;;;  144000))
 ;;; Generated autoloads from helm-grep.el
 
 (autoload 'helm-goto-precedent-file "helm-grep" "\
@@ -399,8 +399,8 @@ With a prefix arg ARG git-grep the whole repository.
 
 ;;;***
 
-;;;### (autoloads nil "helm-help" "helm-help.el" (22527 12706 522693
+;;;### (autoloads nil "helm-help" "helm-help.el" (22532 34656 4333
-;;;;;;  854000))
+;;;;;;  529000))
 ;;; Generated autoloads from helm-help.el
 
 (autoload 'helm-documentation "helm-help" "\
@@ -420,8 +420,8 @@ String displayed in mode-line in `helm-source-find-files'.")
 
 ;;;***
 
-;;;### (autoloads nil "helm-id-utils" "helm-id-utils.el" (22527 12706
+;;;### (autoloads nil "helm-id-utils" "helm-id-utils.el" (22532 34656
-;;;;;;  614693 941000))
+;;;;;;  84334 216000))
 ;;; Generated autoloads from helm-id-utils.el
 
 (autoload 'helm-gid "helm-id-utils" "\
@@ -435,8 +435,8 @@ See <https://www.gnu.org/software/idutils/>.
 
 ;;;***
 
-;;;### (autoloads nil "helm-imenu" "helm-imenu.el" (22527 12706 594693
+;;;### (autoloads nil "helm-imenu" "helm-imenu.el" (22532 34656 68334
-;;;;;;  922000))
+;;;;;;  79000))
 ;;; Generated autoloads from helm-imenu.el
 
 (autoload 'helm-imenu "helm-imenu" "\
@@ -453,8 +453,8 @@ or it have an association in `helm-imenu-all-buffer-assoc'.
 
 ;;;***
 
-;;;### (autoloads nil "helm-info" "helm-info.el" (22527 12706 586693
+;;;### (autoloads nil "helm-info" "helm-info.el" (22532 34656 64334
-;;;;;;  915000))
+;;;;;;  44000))
 ;;; Generated autoloads from helm-info.el
 
 (autoload 'helm-info "helm-info" "\
@@ -470,8 +470,8 @@ With a prefix-arg insert symbol at point.
 
 ;;;***
 
-;;;### (autoloads nil "helm-locate" "helm-locate.el" (22527 12706
+;;;### (autoloads nil "helm-locate" "helm-locate.el" (22532 34656
-;;;;;;  534693 865000))
+;;;;;;  20333 666000))
 ;;; Generated autoloads from helm-locate.el
 
 (autoload 'helm-projects-find-files "helm-locate" "\
@@ -498,8 +498,8 @@ Where db_path is a filename matched by
 
 ;;;***
 
-;;;### (autoloads nil "helm-man" "helm-man.el" (22527 12706 666693
+;;;### (autoloads nil "helm-man" "helm-man.el" (22532 34656 144334
-;;;;;;  991000))
+;;;;;;  731000))
 ;;; Generated autoloads from helm-man.el
 
 (autoload 'helm-man-woman "helm-man" "\
@@ -510,8 +510,8 @@ With a prefix arg reinitialize the cache.
 
 ;;;***
 
-;;;### (autoloads nil "helm-misc" "helm-misc.el" (22527 12706 654693
+;;;### (autoloads nil "helm-misc" "helm-misc.el" (22532 34656 124334
-;;;;;;  979000))
+;;;;;;  560000))
 ;;; Generated autoloads from helm-misc.el
 
 (autoload 'helm-browse-menubar "helm-misc" "\
@@ -552,8 +552,8 @@ Preconfigured `helm' that provide completion of `comint' history.
 
 ;;;***
 
-;;;### (autoloads nil "helm-mode" "helm-mode.el" (22527 12706 510693
+;;;### (autoloads nil "helm-mode" "helm-mode.el" (22532 34655 992333
-;;;;;;  842000))
+;;;;;;  424000))
 ;;; Generated autoloads from helm-mode.el
 
 (autoload 'helm-comp-read "helm-mode" "\
@@ -724,8 +724,8 @@ Note: This mode is incompatible with Emacs23.
 
 ;;;***
 
-;;;### (autoloads nil "helm-net" "helm-net.el" (22527 12706 682694
+;;;### (autoloads nil "helm-net" "helm-net.el" (22532 34656 164334
-;;;;;;  6000))
+;;;;;;  903000))
 ;;; Generated autoloads from helm-net.el
 
 (autoload 'helm-surfraw "helm-net" "\
@@ -745,8 +745,8 @@ Preconfigured `helm' for Wikipedia lookup with Wikipedia suggest.
 
 ;;;***
 
-;;;### (autoloads nil "helm-org" "helm-org.el" (22527 12706 714694
+;;;### (autoloads nil "helm-org" "helm-org.el" (22532 34656 196335
-;;;;;;  36000))
+;;;;;;  178000))
 ;;; Generated autoloads from helm-org.el
 
 (autoload 'helm-org-agenda-files-headings "helm-org" "\
@@ -777,8 +777,8 @@ Preconfigured helm for org templates.
 
 ;;;***
 
-;;;### (autoloads nil "helm-regexp" "helm-regexp.el" (22527 12706
+;;;### (autoloads nil "helm-regexp" "helm-regexp.el" (22532 34656
-;;;;;;  678694 1000))
+;;;;;;  160334 869000))
 ;;; Generated autoloads from helm-regexp.el
 
 (autoload 'helm-moccur-mode "helm-regexp" "\
@@ -817,8 +817,8 @@ The prefix arg can be set before calling
 
 ;;;***
 
-;;;### (autoloads nil "helm-ring" "helm-ring.el" (22527 12706 518693
+;;;### (autoloads nil "helm-ring" "helm-ring.el" (22532 34656 333
-;;;;;;  850000))
+;;;;;;  494000))
 ;;; Generated autoloads from helm-ring.el
 
 (defvar helm-push-mark-mode nil "\
@@ -876,8 +876,8 @@ This command is useful when used with persistent action.
 
 ;;;***
 
-;;;### (autoloads nil "helm-semantic" "helm-semantic.el" (22527 12706
+;;;### (autoloads nil "helm-semantic" "helm-semantic.el" (22532 34656
-;;;;;;  602693 930000))
+;;;;;;  76334 146000))
 ;;; Generated autoloads from helm-semantic.el
 
 (autoload 'helm-semantic "helm-semantic" "\
@@ -899,8 +899,8 @@ Fill in the symbol at point by default.
 
 ;;;***
 
-;;;### (autoloads nil "helm-sys" "helm-sys.el" (22527 12706 622693
+;;;### (autoloads nil "helm-sys" "helm-sys.el" (22532 34656 104334
-;;;;;;  949000))
+;;;;;;  388000))
 ;;; Generated autoloads from helm-sys.el
 
 (defvar helm-top-poll-mode nil "\
@@ -935,8 +935,8 @@ Preconfigured helm for xrandr.
 
 ;;;***
 
-;;;### (autoloads nil "helm-tags" "helm-tags.el" (22527 12706 574693
+;;;### (autoloads nil "helm-tags" "helm-tags.el" (22532 34656 48333
-;;;;;;  902000))
+;;;;;;  906000))
 ;;; Generated autoloads from helm-tags.el
 
 (autoload 'helm-etags-select "helm-tags" "\
@@ -955,8 +955,8 @@ This function aggregates three sources of tag files:
 
 ;;;***
 
-;;;### (autoloads nil "helm-utils" "helm-utils.el" (22527 12706 542693
+;;;### (autoloads nil "helm-utils" "helm-utils.el" (22532 34656 28333
-;;;;;;  873000))
+;;;;;;  734000))
 ;;; Generated autoloads from helm-utils.el
 
 (defvar helm-popup-tip-mode nil "\
@@ -977,7 +977,7 @@ Show help-echo informations in a popup tip at end of line.
 ;;;***
 
 ;;;### (autoloads nil nil ("helm-easymenu.el" "helm-pkg.el" "helm-types.el")
-;;;;;;  (22527 12706 722694 43000))
+;;;;;;  (22532 34656 204335 248000))
 
 ;;;***
 

elpa/helm-20161016.827/helm-grep.el

@@ -417,10 +417,12 @@ It is intended to use as a let-bound variable, DON'T set this globaly.")
                                  ;; we need to pass an empty string
                                  ;; to types to avoid error.
                                  (or include "")))
-         (smartcase         (if (helm-grep-use-ack-p) ""
+         (smartcase         (if (helm-grep-use-ack-p)
-                              (unless (let ((case-fold-search nil))
+                                ""
-                                        (string-match-p
+                                (unless (let ((case-fold-search nil))
-                                         "[[:upper:]]" helm-pattern)) "i")))
+                                          (string-match-p
+                                           "[[:upper:]]" helm-pattern))
+                                  "i")))
          (helm-grep-default-command
           (concat helm-grep-default-command " %m")) ; `%m' like multi.
          (patterns (split-string helm-pattern))
@@ -429,8 +431,10 @@ It is intended to use as a let-bound variable, DON'T set this globaly.")
               (cl-loop with pipcom = (pcase (helm-grep-command)
                                        ;; Use grep for GNU regexp based tools.
                                        ((or "grep" "zgrep" "git-grep")
-                                        (format "grep --color=always %s"
+                                        (replace-regexp-in-string
-                                                (if smartcase "-i" "")))
+                                         "\\s-\\'" ""
+                                         (format "grep --color=always %s"
+                                                 (if smartcase "-i" ""))))
                                        ;; Use ack-grep for PCRE based tools.
                                        ;; Sometimes ack-grep cmd is ack only.
                                        ((and (pred (string-match-p "ack")) ack)
@@ -1259,49 +1263,76 @@ If a prefix arg is given run grep on all buffers ignoring non--file-buffers."
      (format-spec helm-pdfgrep-default-read-command
                   (list (cons ?f fname) (cons ?p pageno))))))
 
-;;; AG - PT
+;;; AG - PT - RG
 ;;
 ;;  https://github.com/ggreer/the_silver_searcher
 ;;  https://github.com/monochromegane/the_platinum_searcher
+;;  https://github.com/BurntSushi/ripgrep
 
 (defcustom helm-grep-ag-command
   "ag --line-numbers -S --hidden --color --nogroup %s %s %s"
-  "The default command for AG or PT.
+  "The default command for AG, PT or RG.
+
 Takes three format specs, the first for type(s), the second for pattern
 and the third for directory.
 
+Here the command line to use with ripgrep:
+
+    rg --smart-case --no-heading --line-number %s %s %s
+
+If you want native color output with ripgrep (--color=always)
+you have to use a workaround as ripgrep is not supporting emacs
+dumb terminal, here it is:
+
+    TERM=eterm-color rg --color=always --smart-case --no-heading --line-number %s %s %s
+
 You must use an output format that fit with helm grep, that is:
 
     \"filename:line-number:string\"
 
 The option \"--nogroup\" allow this.
 The option \"--line-numbers\" is also mandatory except with PT (not supported).
+For RG the options \"--no-heading\" and \"--line-number\" are the ones to use.
 
-You can use safely \"--color\" (default)."
+You can use safely \"--color\" (used by default) with AG and PT."
   :group 'helm-grep
   :type 'string)
 
 (defun helm-grep--ag-command ()
-  (car (split-string helm-grep-ag-command)))
+  (car (helm-remove-if-match
+        "\\`[A-Z]*=" (split-string helm-grep-ag-command))))
 
 (defun helm-grep-ag-get-types ()
   "Returns a list of AG types if available with AG version.
-See AG option \"--list-file-types\"."
+See AG option \"--list-file-types\"
+Ripgrep (rg) types are also supported if this backend is used."
   (with-temp-buffer
-    (when (equal (call-process (helm-grep--ag-command)
+    (let* ((com (helm-grep--ag-command))
-                               nil t nil "--list-file-types") 0)
+           (ripgrep (string= com "rg"))
-      (goto-char (point-min))
+           (regex (if ripgrep "^\\(.*\\):" "^ *\\(--[a-z]*\\)"))
-      (cl-loop while (re-search-forward "^ *\\(--[a-z]*\\)" nil t)
+           (prefix (if ripgrep "-t" "")))
-               collect (match-string 1)))))
+      (when (equal (call-process com
+                                 nil t nil
+                                 (if ripgrep
+                                     "--type-list" "--list-file-types")) 0)
+        (goto-char (point-min))
+        (cl-loop while (re-search-forward regex nil t)
+                 for type = (match-string 1)
+                 collect (cons type (concat prefix type)))))))
 
 (defun helm-grep-ag-prepare-cmd-line (pattern directory &optional type)
   "Prepare AG command line to search PATTERN in DIRECTORY.
 When TYPE is specified it is one of what returns `helm-grep-ag-get-types'
 if available with current AG version."
   (let* ((patterns (split-string pattern))
-         (pipe-cmd (cond ((executable-find "ack") "ack --color")
+         (smartcase (let ((case-fold-search nil))
-                         ((executable-find "ack-grep") "ack-grep --color")
+                      (string-match-p
-                         (t "grep --perl-regexp --color=always")))
+                       "[[:upper:]]" helm-pattern)))
+         (pipe-cmd (cond ((executable-find "ack") "ack --smart-case --color")
+                         ((executable-find "ack-grep") "ack-grep --smart-case --color")
+                         (t (replace-regexp-in-string
+                             "\\s-\\'" "" (format "grep --perl-regexp --color=always %s"
+                                                  (if smartcase "-i" ""))))))
          (cmd (format helm-grep-ag-command
                       (mapconcat 'identity type " ")
                       (shell-quote-argument (car patterns))

elpa/helm-20161016.827/helm-org.el

@@ -58,7 +58,7 @@ Note this have no effect in `helm-org-in-buffer-headings'."
 (defcustom helm-org-headings-actions
   '(("Go to heading" . helm-org-goto-marker)
     ("Open in indirect buffer `C-c i'" . helm-org--open-heading-in-indirect-buffer)
-    ("Refile to this heading `C-c w`" . helm-org-heading-refile)
+    ("Refile current heading to selected heading `C-c w`" . helm-org-heading-refile)
     ("Insert link to this heading `C-c l`" . helm-org-insert-link-to-heading-at-marker))
   "Default actions alist for
   `helm-source-org-headings-for-files'."

elpa/helm-20161016.827/helm-pkg.el

@@ -1,8 +1,8 @@
-(define-package "helm" "20161010.1043" "Helm is an Emacs incremental and narrowing framework"
+(define-package "helm" "20161016.827" "Helm is an Emacs incremental and narrowing framework"
   '((emacs "24.4")
     (async "1.9")
     (popup "0.5.3")
-    (helm-core "2.2.1"))
+    (helm-core "2.3.0"))
   :url "https://emacs-helm.github.io/helm/")
 ;; Local Variables:
 ;; no-byte-compile: t

elpa/helm-core-20161015.2348/helm-core-autoloads.el

@@ -3,7 +3,7 @@
 ;;; Code:
 (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
 
-;;;### (autoloads nil "helm" "helm.el" (22527 12704 426691 871000))
+;;;### (autoloads nil "helm" "helm.el" (22532 34653 700313 729000))
 ;;; Generated autoloads from helm.el
 
 (autoload 'helm-define-multi-key "helm" "\
@@ -188,7 +188,7 @@ Enable/disable helm debugging from outside of helm session.
 ;;;***
 
 ;;;### (autoloads nil nil ("helm-core-pkg.el" "helm-lib.el" "helm-multi-match.el"
-;;;;;;  "helm-source.el") (22527 12704 442691 886000))
+;;;;;;  "helm-source.el") (22532 34653 712313 831000))
 
 ;;;***
 

elpa/helm-core-20161015.2348/helm-core-pkg.el

@@ -1,4 +1,4 @@
-(define-package "helm-core" "20161012.1153" "Development files for Helm"
+(define-package "helm-core" "20161015.2348" "Development files for Helm"
   '((emacs "24.4")
     (async "1.9"))
   :url "https://emacs-helm.github.io/helm/")

elpa/helm-core-20161015.2348/helm.el

@@ -4704,40 +4704,51 @@ Returns the resulting buffer."
   "Toggle resplit helm window, vertically or horizontally."
   (interactive)
   (with-helm-alive-p
-    (when helm-prevent-escaping-from-minibuffer
+    (if(= (length (window-list nil 1)) 2)
-      (helm-prevent-switching-other-window :enabled nil))
+       (progn
-    (unwind-protect
+         (when helm-prevent-escaping-from-minibuffer
-         (with-helm-window
+           (helm-prevent-switching-other-window :enabled nil))
-           (cond ((or helm-full-frame (one-window-p t))
+         (unwind-protect
-                  (user-error "Attempt to resplit a single window"))
+              (with-helm-window
-                 ((helm-action-window)
+                (cond ((or helm-full-frame (one-window-p t))
-                  (user-error "Can't resplit while selecting actions"))
+                       (user-error "Attempt to resplit a single window"))
-                 (t
+                      ((helm-action-window)
-                  (let ((before-height (window-height)))
+                       (user-error "Can't resplit while selecting actions"))
-                    (delete-window)
+                      (t
-                    (set-window-buffer
+                       (let* ((before-height (window-height))
-                     (select-window
+                              (ow (or (and (window-live-p helm-persistent-action-display-window)
-                      (if (= (window-height) before-height) ; initial split was horizontal.
+                                           helm-persistent-action-display-window)
-                          ;; Split window vertically with `helm-buffer' placed
+                                      (get-buffer-window helm-current-buffer)))
-                          ;; on the good side according to actual value of
+                              (ow-buf (window-buffer ow)))
-                          ;; `helm-split-window-default-side'.
+                         (delete-window ow)
-                          (prog1
+                         (set-window-buffer
-                              (cond ((or (eq helm-split-window-default-side 'above)
+                          (if (= (window-height) before-height) ; initial split was horizontal.
-                                         (eq helm-split-window-default-side 'left))
+                              ;; Split window vertically with `helm-buffer' placed
-                                     (split-window
+                              ;; on the good side according to actual value of
-                                      (selected-window) nil 'above))
+                              ;; `helm-split-window-default-side'.
-                                    (t (split-window-vertically)))
+                              (prog1
-                            (setq helm-split-window-state 'vertical))
+                                  (cond ((or (eq helm-split-window-default-side 'above)
-                          ;; Split window vertically, same comment as above.
+                                             (eq helm-split-window-default-side 'left))
-                          (setq helm-split-window-state 'horizontal)
+                                         (split-window (helm-window) nil 'below))
-                          (cond ((or (eq helm-split-window-default-side 'left)
+                                        ((or (eq helm-split-window-default-side 'below)
-                                     (eq helm-split-window-default-side 'above))
+                                             (eq helm-split-window-default-side 'right))
-                                 (split-window (selected-window) nil 'left))
+                                         (split-window (helm-window) nil 'above))
-                                (t (split-window-horizontally)))))
+                                        (t (split-window-vertically)))
-                     helm-buffer))))
+                                (setq helm-split-window-state 'vertical))
-           (setq helm--window-side-state (helm--get-window-side-state)))
+                              ;; Split window vertically, same comment as above.
-      (when helm-prevent-escaping-from-minibuffer
+                              (setq helm-split-window-state 'horizontal)
-        (helm-prevent-switching-other-window :enabled t)))))
+                              (cond ((or (eq helm-split-window-default-side 'left)
+                                         (eq helm-split-window-default-side 'above))
+                                     (split-window (helm-window) nil 'right))
+                                    ((or (eq helm-split-window-default-side 'right)
+                                         (eq helm-split-window-default-side 'below))
+                                     (split-window (helm-window) nil 'left))
+                                    (t (split-window-horizontally))))
+                          ow-buf))))
+                (setq helm--window-side-state (helm--get-window-side-state))))
+         (when helm-prevent-escaping-from-minibuffer
+           (helm-prevent-switching-other-window :enabled t)))
+       (error "current window configuration not suitable for splitting"))))
 (put 'helm-toggle-resplit-window 'helm-only t)
 
 ;; Utility: Resize helm window.
@@ -4767,46 +4778,42 @@ If N is positive enlarge, if negative narrow."
   "Swap window holding `helm-buffer' with other window."
   (interactive)
   (with-helm-alive-p
-    (cond ((and helm-full-frame (one-window-p t))
+    (if (= (length (window-list nil 1)) 2)
-           (user-error "Can't swap windows in a single window"))
+        (cond ((and helm-full-frame (one-window-p t))
-          ((helm-action-window)
+               (user-error "Can't swap windows in a single window"))
-           (user-error "Can't resplit while selecting actions"))
+              ((helm-action-window)
-          (t
+               (user-error "Can't resplit while selecting actions"))
-           (let* ((w1          (helm-window))
+              (t
-                  (split-state (eq helm-split-window-state 'horizontal))
+               (let* ((w1          (helm-window))
-                  (w1size      (window-total-size w1 split-state))
+                      (split-state (eq helm-split-window-state 'horizontal))
-                  (b1          (window-buffer w1)) ; helm-buffer
+                      (w1size      (window-total-size w1 split-state))
-                  (s1          (window-start w1))
+                      (s1          (window-start w1))
-                  (cur-frame   (window-frame w1))
+                      (w2          (or (and (window-live-p helm-persistent-action-display-window)
-                  (w2          (with-selected-window (helm-window)
+                                            helm-persistent-action-display-window)
-                                 ;; Don't try to display helm-buffer
+                                       (get-buffer-window helm-current-buffer)))
-                                 ;; in a dedicated window.
+                      (w2size      (window-total-size w2 split-state))
-                                 (get-window-with-predicate
+                      (b2          (window-buffer w2)) ; probably helm-current-buffer
-                                  (lambda (w) (not (window-dedicated-p w)))
+                      (s2          (window-start w2))
-                                  1 cur-frame)))
+                      (resize      (cond ( ;; helm-window is smaller than other window.
-                  (w2size      (window-total-size w2 split-state))
+                                          (< w1size w2size)
-                  (b2          (window-buffer w2)) ; probably helm-current-buffer
+                                          (- (- (max w2size w1size)
-                  (s2          (window-start w2))
+                                                (min w2size w1size))))
-                  resize)
+                                         ( ;; helm-window is larger than other window.
-             (with-selected-frame (window-frame w1)
+                                          (> w1size w2size)
-               (helm-replace-buffer-in-window w1 b1 b2)
+                                          (- (max w2size w1size)
-               (helm-replace-buffer-in-window w2 b2 b1)
+                                             (min w2size w1size)))
-               (setq resize
+                                         ( ;; windows have probably same size.
-                     (cond ( ;; helm-window is smaller than other window.
+                                          t nil))))
-                            (< w1size w2size)
+                 (with-selected-frame (window-frame w1)
-                            (- (- (max w2size w1size)
+                   (delete-window w2)
-                                  (min w2size w1size))))
+                   (set-window-buffer
-                           ( ;; helm-window is larger than other window.
+                    (setq w2 (split-window w1 nil helm--window-side-state)) b2)
-                            (> w1size w2size)
+                   ;; Maybe resize the window holding helm-buffer.
-                            (- (max w2size w1size)
+                   (and resize (window-resize w2 resize split-state))
-                               (min w2size w1size)))
+                   (set-window-start w1 s2 t)
-                           ( ;; windows have probably same size.
+                   (set-window-start w2 s1 t))
-                            t nil)))
+                 (setq helm--window-side-state (helm--get-window-side-state)))))
-               ;; Maybe resize the window holding helm-buffer.
+        (error "current window configuration not suitable for splitting"))))
-               (and resize (window-resize w2 resize split-state))
-               (set-window-start w1 s2 t)
-               (set-window-start w2 s1 t))
-             (setq helm--window-side-state (helm--get-window-side-state)))))))
 (put 'helm-swap-windows 'helm-only t)
 
 (defun helm--get-window-side-state ()

elpa/js2-mode-20161016.156/js2-mode-autoloads.el

@@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
 
-;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (22528
+;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (22532
-;;;;;;  31234 288278 643000))
+;;;;;;  34642 100214 174000))
 ;;; Generated autoloads from js2-imenu-extras.el
 
 (autoload 'js2-imenu-extras-setup "js2-imenu-extras" "\
@@ -19,8 +19,8 @@ Toggle Imenu support for frameworks and structural patterns.
 
 ;;;***
 
-;;;### (autoloads nil "js2-mode" "js2-mode.el" (22528 31234 308278
+;;;### (autoloads nil "js2-mode" "js2-mode.el" (22532 34642 124214
-;;;;;;  621000))
+;;;;;;  380000))
 ;;; Generated autoloads from js2-mode.el
 
 (autoload 'js2-highlight-unused-variables-mode "js2-mode" "\
@@ -56,7 +56,7 @@ variables (`sgml-basic-offset' et al) locally, like so:
 ;;;***
 
 ;;;### (autoloads nil nil ("js2-mode-pkg.el" "js2-old-indent.el")
-;;;;;;  (22528 31234 300278 630000))
+;;;;;;  (22532 34642 116214 311000))
 
 ;;;***
 

elpa/js2-mode-20161016.156/js2-mode-pkg.el

@@ -1,4 +1,4 @@
-(define-package "js2-mode" "20161013.1644" "Improved JavaScript editing mode"
+(define-package "js2-mode" "20161016.156" "Improved JavaScript editing mode"
   '((emacs "24.1")
     (cl-lib "0.5"))
   :url "https://github.com/mooz/js2-mode/" :keywords

elpa/js2-mode-20161016.156/js2-mode.el

@@ -3773,7 +3773,7 @@ You can tell the quote type by looking at the first character."
                (:include js2-node)
                (:constructor nil)
                (:constructor make-js2-template-node (&key (type js2-TEMPLATE_HEAD)
-                                                          beg len kids)))
+                                                          pos len kids)))
   "Template literal."
   kids)  ; `js2-string-node' is used for string segments, other nodes
          ; for substitutions inside.
@@ -3796,7 +3796,7 @@ You can tell the quote type by looking at the first character."
                (:include js2-node)
                (:constructor nil)
                (:constructor make-js2-tagged-template-node (&key (type js2-TAGGED_TEMPLATE)
-                                                                 beg len tag template)))
+                                                                 pos len tag template)))
   "Tagged template literal."
   tag       ; `js2-node' with the tag expression.
   template) ; `js2-template-node' with the template.
@@ -10157,9 +10157,9 @@ Returns an expression tree that includes PN, the parent node."
 
 (defun js2-parse-tagged-template (tag-node tpl-node)
   "Parse tagged template expression."
-  (let* ((beg (js2-node-pos tag-node))
+  (let* ((pos (js2-node-pos tag-node))
-         (pn (make-js2-tagged-template-node :beg beg
+         (pn (make-js2-tagged-template-node :pos pos
-                                            :len (- (js2-current-token-end) beg)
+                                            :len (- (js2-current-token-end) pos)
                                             :tag tag-node
                                             :template tpl-node)))
     (js2-node-add-children pn tag-node tpl-node)
@@ -10466,7 +10466,7 @@ array-literals, array comprehensions and regular expressions."
       (setq tt (js2-get-token 'TEMPLATE_TAIL))
       (push (make-js2-string-node :type tt) kids))
     (setq kids (nreverse kids))
-    (let ((tpl (make-js2-template-node :beg beg
+    (let ((tpl (make-js2-template-node :pos beg
                                        :len (- (js2-current-token-end) beg)
                                        :kids kids)))
       (apply #'js2-node-add-children tpl kids)

elpa/magit-20161016.1325/magit-autoloads.el

@@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
 
-;;;### (autoloads nil "git-rebase" "git-rebase.el" (22528 41393 93076
+;;;### (autoloads nil "git-rebase" "git-rebase.el" (22532 34650 788288
-;;;;;;  154000))
+;;;;;;  716000))
 ;;; Generated autoloads from git-rebase.el
 
 (autoload 'git-rebase-mode "git-rebase" "\
@@ -23,7 +23,7 @@ running 'man git-rebase' at the command line) for details.
 
 ;;;***
 
-;;;### (autoloads nil "magit" "magit.el" (22528 41393 173076 88000))
+;;;### (autoloads nil "magit" "magit.el" (22532 34650 876289 472000))
 ;;; Generated autoloads from magit.el
 
 (autoload 'magit-status "magit" "\
@@ -501,8 +501,8 @@ Git, and Emacs in the echo area.
 
 ;;;***
 
-;;;### (autoloads nil "magit-apply" "magit-apply.el" (22528 41393
+;;;### (autoloads nil "magit-apply" "magit-apply.el" (22532 34650
-;;;;;;  113076 138000))
+;;;;;;  812288 922000))
 ;;; Generated autoloads from magit-apply.el
 
 (autoload 'magit-stage-file "magit-apply" "\
@@ -538,8 +538,8 @@ Remove all changes from the staging area.
 
 ;;;***
 
-;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (22528
+;;;### (autoloads nil "magit-autorevert" "magit-autorevert.el" (22532
-;;;;;;  41393 49076 189000))
+;;;;;;  34650 752288 407000))
 ;;; Generated autoloads from magit-autorevert.el
 
 (defvar magit-revert-buffers t)
@@ -568,8 +568,8 @@ See `auto-revert-mode' for more information on Auto-Revert mode.
 
 ;;;***
 
-;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (22528 41393
+;;;### (autoloads nil "magit-bisect" "magit-bisect.el" (22532 34650
-;;;;;;  109076 140000))
+;;;;;;  808288 887000))
 ;;; Generated autoloads from magit-bisect.el
  (autoload 'magit-bisect-popup "magit-bisect" nil t)
 
@@ -620,8 +620,8 @@ bisect run'.
 
 ;;;***
 
-;;;### (autoloads nil "magit-blame" "magit-blame.el" (22528 41393
+;;;### (autoloads nil "magit-blame" "magit-blame.el" (22532 34650
-;;;;;;  161076 99000))
+;;;;;;  860289 334000))
 ;;; Generated autoloads from magit-blame.el
  (autoload 'magit-blame-popup "magit-blame" nil t)
 
@@ -645,8 +645,8 @@ only arguments available from `magit-blame-popup' should be used.
 
 ;;;***
 
-;;;### (autoloads nil "magit-commit" "magit-commit.el" (22528 41393
+;;;### (autoloads nil "magit-commit" "magit-commit.el" (22532 34650
-;;;;;;  57076 182000))
+;;;;;;  760288 476000))
 ;;; Generated autoloads from magit-commit.el
 
 (autoload 'magit-commit "magit-commit" "\
@@ -728,8 +728,8 @@ Create a squash commit targeting COMMIT and instantly rebase.
 
 ;;;***
 
-;;;### (autoloads nil "magit-diff" "magit-diff.el" (22528 41393 157076
+;;;### (autoloads nil "magit-diff" "magit-diff.el" (22532 34650 856289
-;;;;;;  101000))
+;;;;;;  300000))
 ;;; Generated autoloads from magit-diff.el
 
 (autoload 'magit-diff-popup "magit-diff" "\
@@ -813,8 +813,8 @@ for a revision.
 
 ;;;***
 
-;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (22528 41393
+;;;### (autoloads nil "magit-ediff" "magit-ediff.el" (22532 34650
-;;;;;;  145076 110000))
+;;;;;;  840289 163000))
 ;;; Generated autoloads from magit-ediff.el
  (autoload 'magit-ediff-popup "magit-ediff" nil t)
 
@@ -902,8 +902,8 @@ stash that were staged.
 
 ;;;***
 
-;;;### (autoloads nil "magit-extras" "magit-extras.el" (22528 41393
+;;;### (autoloads nil "magit-extras" "magit-extras.el" (22532 34650
-;;;;;;  61076 179000))
+;;;;;;  764288 510000))
 ;;; Generated autoloads from magit-extras.el
 
 (autoload 'magit-run-git-gui "magit-extras" "\
@@ -973,8 +973,8 @@ on a position in a file-visiting buffer.
 
 ;;;***
 
-;;;### (autoloads nil "magit-log" "magit-log.el" (22528 41393 149076
+;;;### (autoloads nil "magit-log" "magit-log.el" (22532 34650 844289
-;;;;;;  107000))
+;;;;;;  196000))
 ;;; Generated autoloads from magit-log.el
 
 (autoload 'magit-log-buffer-file-popup "magit-log" "\
@@ -1056,8 +1056,8 @@ Show commits in a branch that are not merged in the upstream branch.
 
 ;;;***
 
-;;;### (autoloads nil "magit-remote" "magit-remote.el" (22528 41393
+;;;### (autoloads nil "magit-remote" "magit-remote.el" (22532 34650
-;;;;;;  189076 75000))
+;;;;;;  892289 610000))
 ;;; Generated autoloads from magit-remote.el
 
 (autoload 'magit-clone "magit-remote" "\
@@ -1289,8 +1289,8 @@ is asked to pull.  START has to be reachable from that commit.
 
 ;;;***
 
-;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (22528
+;;;### (autoloads nil "magit-sequence" "magit-sequence.el" (22532
-;;;;;;  41393 177076 85000))
+;;;;;;  34650 884289 540000))
 ;;; Generated autoloads from magit-sequence.el
 
 (autoload 'magit-sequencer-continue "magit-sequence" "\
@@ -1440,8 +1440,8 @@ Abort the current rebase operation, restoring the original branch.
 
 ;;;***
 
-;;;### (autoloads nil "magit-stash" "magit-stash.el" (22528 41393
+;;;### (autoloads nil "magit-stash" "magit-stash.el" (22532 34650
-;;;;;;  133076 121000))
+;;;;;;  832289 94000))
 ;;; Generated autoloads from magit-stash.el
  (autoload 'magit-stash-popup "magit-stash" nil t)
 
@@ -1540,8 +1540,8 @@ Show all diffs of a stash in a buffer.
 
 ;;;***
 
-;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (22528
+;;;### (autoloads nil "magit-submodule" "magit-submodule.el" (22532
-;;;;;;  41393 213076 56000))
+;;;;;;  34650 908289 747000))
 ;;; Generated autoloads from magit-submodule.el
  (autoload 'magit-submodule-popup "magit-submodule" nil t)
 
@@ -1631,8 +1631,8 @@ Display a list of the current repository's submodules.
 
 ;;;***
 
-;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (22528 41393
+;;;### (autoloads nil "magit-subtree" "magit-subtree.el" (22532 34650
-;;;;;;  101076 146000))
+;;;;;;  792288 750000))
 ;;; Generated autoloads from magit-subtree.el
  (autoload 'magit-subtree-popup "magit-subtree" nil t)
 
@@ -1668,8 +1668,8 @@ Extract the history of the subtree PREFIX.
 
 ;;;***
 
-;;;### (autoloads nil "magit-wip" "magit-wip.el" (22528 41393 73076
+;;;### (autoloads nil "magit-wip" "magit-wip.el" (22532 34650 776288
-;;;;;;  170000))
+;;;;;;  613000))
 ;;; Generated autoloads from magit-wip.el
 
 (defvar magit-wip-after-save-mode nil "\
@@ -1739,7 +1739,7 @@ command which is about to be called are committed.
 
 ;;;### (autoloads nil nil ("magit-core.el" "magit-git.el" "magit-mode.el"
 ;;;;;;  "magit-pkg.el" "magit-process.el" "magit-section.el" "magit-utils.el")
-;;;;;;  (22528 41393 197076 69000))
+;;;;;;  (22532 34650 896289 644000))
 
 ;;;***
 

elpa/magit-20161016.1325/magit-pkg.el

@@ -1,4 +1,4 @@
-(define-package "magit" "20161013.1332" "A Git porcelain inside Emacs"
+(define-package "magit" "20161016.1325" "A Git porcelain inside Emacs"
   '((emacs "24.4")
     (async "20160711.223")
     (dash "20160820.501")

elpa/magit-20161016.1325/magit.el

@@ -3074,9 +3074,10 @@ With prefix argument simply read a directory name using
   (cond ((file-readable-p (expand-file-name ".git" directory))
          (list directory))
         ((and (> depth 0) (magit-file-accessible-directory-p directory))
-         (--mapcat (when (file-directory-p it)
+         (--mapcat (and (file-directory-p it)
-                     (magit-list-repos-1 it (1- depth)))
+                        (magit-list-repos-1 it (1- depth)))
-                   (directory-files directory t "^[^.]" t)))))
+                   (directory-files directory t
+                                    directory-files-no-dot-files-regexp t)))))
 
 (defun magit-list-repos-uniquify (alist)
   (let (result (dict (make-hash-table :test 'equal)))

elpa/smartparens-20161014.323/smartparens-pkg.el

@@ -1,6 +0,0 @@
-(define-package "smartparens" "20161014.323" "Automatic insertion, wrapping and paredit-like navigation with user defined pairs."
-  '((dash "2.12.1")
-    (cl-lib "0.3")))
-;; Local Variables:
-;; no-byte-compile: t
-;; End:

elpa/smartparens-20161015.1227/smartparens-autoloads.el

@@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
 
-;;;### (autoloads nil "smartparens" "smartparens.el" (22528 49222
+;;;### (autoloads nil "smartparens" "smartparens.el" (22532 34646
-;;;;;;  858279 896000))
+;;;;;;  720253 798000))
 ;;; Generated autoloads from smartparens.el
 
 (autoload 'sp-cheat-sheet "smartparens" "\
@@ -185,8 +185,8 @@ Turn off `show-smartparens-mode'.
 ;;;;;;  "smartparens-ess.el" "smartparens-haskell.el" "smartparens-html.el"
 ;;;;;;  "smartparens-latex.el" "smartparens-lua.el" "smartparens-pkg.el"
 ;;;;;;  "smartparens-python.el" "smartparens-racket.el" "smartparens-ruby.el"
-;;;;;;  "smartparens-rust.el" "smartparens-scala.el") (22528 49222
+;;;;;;  "smartparens-rust.el" "smartparens-scala.el") (22532 34646
-;;;;;;  894279 852000))
+;;;;;;  756254 106000))
 
 ;;;***
 

elpa/smartparens-20161015.1227/smartparens-clojure.el

@@ -45,5 +45,12 @@
 (dolist (mode '(clojure-mode clojurescript-mode clojurec-mode cider-repl-mode))
   (add-to-list 'sp-sexp-prefix `(,mode regexp ,sp-clojure-prefix)))
 
+;; Match "`" with "`" in strings and comments
+(sp-with-modes sp-clojure-modes
+  (sp-local-pair "`" "`"
+                 :when '(sp-in-string-p
+                         sp-in-comment-p)
+                 :unless '(sp-lisp-invalid-hyperlink-p)))
+
 (provide 'smartparens-clojure)
 ;;; smartparens-clojure.el ends here

elpa/smartparens-20161015.1227/smartparens-config.el

@@ -65,7 +65,9 @@
 ;; lisp modes too
 (sp-with-modes sp-lisp-modes
   ;; disable ', it's the quote character!
-  (sp-local-pair "'" nil :actions nil)
+  (sp-local-pair "'" nil :actions nil))
+
+(sp-with-modes (-difference sp-lisp-modes sp-clojure-modes)
   ;; also only use the pseudo-quote inside strings where it serve as
   ;; hyperlink.
   (sp-local-pair "`" "'"

elpa/smartparens-20161015.1227/smartparens-pkg.el

@@ -0,0 +1,6 @@
+(define-package "smartparens" "20161015.1227" "Automatic insertion, wrapping and paredit-like navigation with user defined pairs."
+  '((dash "2.12.1")
+    (cl-lib "0.3")))
+;; Local Variables:
+;; no-byte-compile: t
+;; End:

elpa/smartparens-20161015.1227/smartparens.el

@@ -516,7 +516,19 @@ Symbol is defined as a chunk of text recognized by
                            slime-repl-mode
                            stumpwm-mode
                            )
-  "List of Lisp modes."
+  "List of Lisp-related modes."
+  :type '(repeat symbol)
+  :group 'smartparens)
+
+(defcustom sp-clojure-modes '(
+                              cider-repl-mode
+                              clojure-mode
+                              clojurec-mode
+                              clojurescript-mode
+                              clojurex-mode
+                              inf-clojure-mode
+                              )
+  "List of Clojure-related modes."
   :type '(repeat symbol)
   :group 'smartparens)
 
@@ -1300,8 +1312,10 @@ This can be used with `sp-local-pair' calls to automatically
 insert the modes."
   (declare (indent 1)
            (debug (form body)))
-  `(progn
+  (let ((modes (make-symbol "modes")))
-     ,@(mapcar (lambda (form) (append (list (car form) arg) (cdr form))) forms)))
+    `(let ((,modes ,arg))
+       (progn
+         ,@(mapcar (lambda (form) (append (list (car form) modes) (cdr form))) forms)))))
 
 (font-lock-add-keywords 'emacs-lisp-mode `((,(concat "("
                                                      (regexp-opt '("sp-with-modes"
@@ -1358,6 +1372,17 @@ sexp, otherwise the call may be very slow."
                    "\\`[ \t\n]*\\'"
                    (buffer-substring-no-properties :beg-in :end-in))))))
 
+(defun sp-char-is-escaped-p (&optional point)
+  "Test if the char at POINT is escaped or not.
+
+POINT defaults to `point'."
+  (setq point (or point (point)))
+  (save-match-data
+    (when (save-excursion
+            (goto-char point)
+            (looking-back (concat sp-escape-char sp-escape-char "+") nil t))
+      (eq (logand (length (match-string 0)) 1) 1))))
+
 (defun sp--syntax-ppss (&optional p)
   "Memoize the last result of syntax-ppss."
   (let ((p (or p (point))))
@@ -2823,8 +2848,15 @@ see `sp-pair' for description."
               (condition-case err
                   (sp-wrap--initialize)
                 (user-error
-                 (delete-char -1)
                  (message (error-message-string err))
+                 ;; we need to remove the undo record of the insertion
+                 (unless (eq buffer-undo-list t)
+                   ;; pop all undo info until we hit an insertion node
+                   (sp--undo-pop-to-last-insertion-node)
+                   ;; get rid of it and insert an undo boundary marker
+                   (pop buffer-undo-list)
+                   (undo-boundary))
+                 (restore-buffer-modified-p sp-buffer-modified-p)
                  (throw 'done nil))))
             (cond
              (sp-wrap-overlays
@@ -3038,12 +3070,44 @@ overlay."
       ;; TODO: get rid of the following variables
       (setq sp-wrap-point (- (point) inserted-string-length))
       (setq sp-wrap-mark (mark))
-      (unless (or (sp-point-in-string (point))
+      ;; balance check
-                  (sp-point-in-string (mark)))
+      (with-silent-modifications
-        (unless (sp-region-ok-p
+        (let ((inserted-string
-                 (if (> (point) (mark)) sp-wrap-point (point))
+               (prog1 (delete-and-extract-region sp-wrap-point (point))
-                 (mark))
+                 ;; HACK: in modes with string fences, the insertion
-          (user-error "Wrapping active region would break structure")))
+                 ;; of the delimiter causes `syntax-propertize' to
+                 ;; fire, but the above deletion doesn't re-run it
+                 ;; because the cache tells it the state is OK.  We
+                 ;; need to destroy the cache and re-run the
+                 ;; `syntax-propertize' on the buffer.  This might be
+                 ;; expensive, but we only done this on wrap-init so
+                 ;; it's fine, I guess.
+                 (setq syntax-propertize--done -1)
+                 (syntax-propertize (point-max))))
+              (point-string-context (sp-get-quoted-string-bounds sp-wrap-point))
+              (mark-string-context (sp-get-quoted-string-bounds (mark))))
+          ;; If point and mark are inside the same string, we don't
+          ;; need to check if the region is OK.  If both are outisde
+          ;; strings, we have to.  If one is inside and the other is
+          ;; not, no matter what we would break, so we exit.
+          (cond
+           ;; inside the same string
+           ((and point-string-context mark-string-context
+                 (eq (car point-string-context)
+                     (car mark-string-context))))
+           ;; neither is inside string
+           ((and (not point-string-context)
+                 (not mark-string-context))
+            (unless (sp-region-ok-p sp-wrap-point (mark))
+              (user-error "Mismatched sexp state: wrapping would break structure")))
+           ;; one is in and the other isn't
+           ((if point-string-context (not mark-string-context) mark-string-context)
+            (user-error "Mismatched string state: point %sin string, mark %sin string"
+                        (if (car-safe point-string-context) "" "not ")
+                        (if (car-safe mark-string-context) "" "not ")))
+           ;; both are in but in different strings
+           (t (user-error "Mismatched string state: point and mark are inside different strings")))
+          (insert inserted-string)))
       ;; if point > mark, we need to move point to mark and reinsert the
       ;; just inserted character.
       (when (> (point) (mark))
@@ -3742,16 +3806,19 @@ sequence, not necessarily the longest possible."
           (to (point))
           (greedy (not not-greedy))
           has-match)
-      (set-match-data '(0 0))
       (if greedy
           (save-excursion
             (goto-char from)
-            (while (and (not has-match) (< (point) to))
+            (save-match-data
-              (looking-at regexp)
+              (while (and (not has-match) (< (point) to))
-              (if (= (match-end 0) to)
+                ;; don't use looking-at because we can't limit that search
-                  (setq has-match t)
+                (if (and (save-excursion (re-search-forward regexp to t))
-                (forward-char 1)))
+                         (= (match-end 0) to))
-            has-match)
+                    (setq has-match (match-data))
+                  (forward-char 1))))
+            (when has-match
+              (set-match-data has-match)
+              t))
         (save-excursion
           (not (null (search-backward-regexp (concat "\\(?:" regexp "\\)\\=") from t))))))))
 
@@ -3775,8 +3842,9 @@ pairs!"
       (while (> count 0)
         (when (search-backward-regexp regexp bound noerror)
           (goto-char (match-end 0))
-          (sp--looking-back regexp)
+          (if (sp--looking-back regexp)
-          (setq r (goto-char (match-beginning 0))))
+              (setq r (goto-char (match-beginning 0)))
+            (if noerror nil (error "Search failed: %s" regexp))))
         (setq count (1- count)))
       r)))
 
@@ -3786,19 +3854,24 @@ pairs!"
   (sp--with-case-sensitive
     (search-forward-regexp regexp bound noerror count)))
 
-(defun sp-get-quoted-string-bounds ()
+(defun sp-get-quoted-string-bounds (&optional point)
-  "Return the bounds of the string around point.
+  "Return the bounds of the string around POINT.
+
+POINT defaults to `point'.
 
 If the point is not inside a quoted string, return nil."
-  (let ((parse-data (syntax-ppss)))
+  (setq point (or point (point)))
-    (when (nth 3 parse-data)
+  (save-excursion
-      (let* ((open (nth 8 parse-data))
+    (goto-char point)
-             (close (save-excursion
+    (let ((parse-data (syntax-ppss)))
-                      (parse-partial-sexp
+      (when (nth 3 parse-data)
-                       (point) (point-max)
+        (let* ((open (nth 8 parse-data))
-                       nil nil parse-data 'syntax-table)
+               (close (save-excursion
-                      (point))))
+                        (parse-partial-sexp
-        (cons open close)))))
+                         (point) (point-max)
+                         nil nil parse-data 'syntax-table)
+                        (point))))
+          (cons open close))))))
 
 ;; TODO: the repeated conditions are ugly, refactor this!
 (defun sp-get-comment-bounds ()
@@ -5048,7 +5121,8 @@ expressions are considered."
                   (sp-get-sexp t))
                  ((sp--valid-initial-delimiter-p (sp--looking-back (sp--get-opening-regexp (sp--get-allowed-pair-list)) nil))
                   (sp-get-sexp t))
-                 ((eq (char-syntax (preceding-char)) 34)
+                 ((and (eq (char-syntax (preceding-char)) 34)
+                       (not (sp-char-is-escaped-p (1- (point)))))
                   (sp-get-string t))
                  ((and (sp--valid-initial-delimiter-p (sp--looking-back (sp--get-stringlike-regexp) nil))
                        (sp-get-expression t)))
@@ -5069,7 +5143,8 @@ expressions are considered."
                 (sp-get-sexp nil))
                ((sp--valid-initial-delimiter-p (sp--looking-at (sp--get-closing-regexp (sp--get-allowed-pair-list))))
                 (sp-get-sexp nil))
-               ((eq (char-syntax (following-char)) 34)
+               ((and (eq (char-syntax (following-char)) 34)
+                     (not (sp-char-is-escaped-p)))
                 (sp-get-string nil))
                ((and (sp--valid-initial-delimiter-p (sp--looking-at (sp--get-stringlike-regexp)))
                      (sp-get-expression nil)))
@@ -5538,6 +5613,11 @@ Examples:
 
 (put 'sp-end-of-previous-sexp 'CUA 'move)
 
+;; TODO: split the reindent code so we can call it inside strings on
+;; sexps like [foo ]... We can't reindent that by default because it
+;; can be a regular expression or something where the whitespace
+;; matters.  For now, disable reindent in strings if the sexp is not
+;; the string quote itself.
 (defun sp-up-sexp (&optional arg interactive)
   "Move forward out of one level of parentheses.
 
@@ -5577,12 +5657,18 @@ Examples:
                        (or (memq major-mode (assq 'always sp-navigate-reindent-after-up))
                            (and (memq major-mode (assq 'interactive sp-navigate-reindent-after-up))
                                 interactive))
-                       (if sp-navigate-reindent-after-up-in-string
+                       (or sp-navigate-reindent-after-up-in-string
-                           t
+                           (sp-get ok (not (sp-point-in-string :end-in))))
-                         (save-excursion
+                       ;; if the sexp to be reindented is not a string
-                           (sp-get ok
+                       ;; but is inside a string, we should rather do
-                             (goto-char :end-in)
+                       ;; nothing than break semantics (in e.g. regexp
-                             (not (sp-point-in-string))))))
+                       ;; [...])
+                       (let ((str (sp-point-in-string)))
+                         (or (not str)
+                             ;; op must be the delimiter of the string we're in
+                             (eq (sp-get ok :op)
+                                 (or (eq str t)
+                                     (char-to-string str))))))
               ;; TODO: this needs different indent rules for different
               ;; modes.  Should we concern with such things?  Lisp rules are
               ;; funny in HTML... :/