Update packages

2016-07-12 15:08:56 +02:00 · 2016-07-12 15:08:56 +02:00 · 314c219408
commit 314c219408
parent 1158f795c5
153 changed files with 694 additions and 1099 deletions
--- a/elpa/ag-20160702.1128/ag-autoloads.el
+++ b/elpa/ag-20160702.1128/ag-autoloads.el
@ -3,11 +3,11 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "ag" "ag.el" (22297 19677 174516 738000))
+;;;### (autoloads nil "ag" "ag.el" (22404 60275 653932 131000))
 ;;; Generated autoloads from ag.el

 (autoload 'ag "ag" "\
-Search using ag in a given DIRECTORY for a given search STRING,
+Search using ag in a given DIRECTORY for a given literal search STRING,
 with STRING defaulting to the symbol under point.

 If called with a prefix, prompts for flags to pass to ag.
@ -15,9 +15,9 @@ If called with a prefix, prompts for flags to pass to ag.
 \(fn STRING DIRECTORY)" t nil)

 (autoload 'ag-files "ag" "\
-Search using ag in a given DIRECTORY for a given search STRING,
-limited to files that match FILE-TYPE. STRING defaults to
-the symbol under point.
+Search using ag in a given DIRECTORY for a given literal search STRING,
+limited to files that match FILE-TYPE. STRING defaults to the
+symbol under point.

 If called with a prefix, prompts for flags to pass to ag.

@ -33,14 +33,14 @@ If called with a prefix, prompts for flags to pass to ag.

 (autoload 'ag-project "ag" "\
 Guess the root of the current project and search it with ag
-for the given string.
+for the given literal search STRING.

 If called with a prefix, prompts for flags to pass to ag.

 \(fn STRING)" t nil)

 (autoload 'ag-project-files "ag" "\
-Search using ag for a given search STRING,
+Search using ag for a given literal search STRING,
 limited to files that match FILE-TYPE. STRING defaults to the
 symbol under point.

@ -62,7 +62,7 @@ If called with a prefix, prompts for flags to pass to ag.
 (defalias 'ag-regexp-project-at-point 'ag-project-regexp)

 (autoload 'ag-dired "ag" "\
-Recursively find files in DIR matching PATTERN.
+Recursively find files in DIR matching literal search STRING.

 The PATTERN is matched against the full path to the file, not
 only against the file name.
@ -72,7 +72,7 @@ The results are presented as a `dired-mode' buffer with

 See also `ag-dired-regexp'.

-\(fn DIR PATTERN)" t nil)
+\(fn DIR STRING)" t nil)

 (autoload 'ag-dired-regexp "ag" "\
 Recursively find files in DIR matching REGEXP.
--- a/elpa/ag-20160702.1128/ag-pkg.el
+++ b/elpa/ag-20160702.1128/ag-pkg.el
@ -1 +1 @@
-(define-package "ag" "20160321.1606" "A front-end for ag ('the silver searcher'), the C ack replacement." '((dash "2.8.0") (s "1.9.0") (cl-lib "0.5")))
+(define-package "ag" "20160702.1128" "A front-end for ag ('the silver searcher'), the C ack replacement." '((dash "2.8.0") (s "1.9.0") (cl-lib "0.5")))
--- a/elpa/ag-20160702.1128/ag.el
+++ b/elpa/ag-20160702.1128/ag.el
@ -5,7 +5,7 @@
 ;; Author: Wilfred Hughes <me@wilfred.me.uk>
 ;; Created: 11 January 2013
 ;; Version: 0.48
-;; Package-Version: 20160321.1606
+;; Package-Version: 20160702.1128
 ;; Package-Requires: ((dash "2.8.0") (s "1.9.0") (cl-lib "0.5"))
 ;;; Commentary:

@ -39,6 +39,11 @@
 (require 's)
 (require 'find-dired) ;; find-dired-filter

+(defgroup ag nil
+  "A front-end for ag - The Silver Searcher."
+  :group 'tools
+  :group 'matching)
+
 (defcustom ag-executable
  "ag"
  "Name of the ag executable to use."
@ -46,17 +51,30 @@
  :group 'ag)

 (defcustom ag-arguments
-  (list "--line-number" "--smart-case" "--nogroup" "--column" "--stats" "--")
-  "Default arguments passed to ag.
+  (list "--smart-case" "--stats")
+  "Additional arguments passed to ag.

-Ag.el requires --nogroup and --column, so we recommend you add any
-additional arguments to the start of this list.
+Ag.el internally uses --column, --line-number and --color
+options (with specific colors) to match groups, so options
+specified here should not conflict.

 --line-number is required on Windows, as otherwise ag will not
 print line numbers when the input is a stream."
  :type '(repeat (string))
  :group 'ag)

+(defcustom ag-context-lines nil
+  "Number of context lines to include before and after a matching line."
+  :type 'integer
+  :group 'ag)
+
+(defcustom ag-group-matches t
+  "Group matches in the same file together.
+
+If nil, the file name is repeated at the beginning of every match line."
+  :type 'boolean
+  :group 'ag)
+
 (defcustom ag-highlight-search nil
  "Non-nil means we highlight the current search term in results.

@ -90,7 +108,7 @@ If set to nil, fall back to finding VCS root directories."
  :group 'ag)

 (defcustom ag-ignore-list nil
-  "A list of patterns to ignore when searching."
+  "A list of patterns for files/directories to ignore when searching."
  :type '(repeat (string))
  :group 'ag)

@ -140,16 +158,29 @@ different window, according to `ag-reuse-window'."
 ;; handle weird file names (with colons in them) as well as possible.
 ;; E.g. we use [1-9][0-9]* rather than [0-9]+ so as to accept ":034:"
 ;; in file names.
-(defvar ag/file-column-pattern
+(defvar ag/file-column-pattern-nogroup
  "^\\(.+?\\):\\([1-9][0-9]*\\):\\([1-9][0-9]*\\):"
  "A regexp pattern that groups output into filename, line number and column number.")

+(defvar ag/file-column-pattern-group
+  "^\\([[:digit:]]+\\):\\([[:digit:]]+\\):"
+  "A regexp pattern to match line number and column number with grouped output.")
+
+(defun ag/compilation-match-grouped-filename ()
+  "Match filename backwards when a line/column match is found in grouped output mode."
+  (save-match-data
+    (save-excursion
+      (when (re-search-backward "^File: \\(.*\\)$" (point-min) t)
+        (list (match-string 1))))))
+
 (define-compilation-mode ag-mode "Ag"
  "Ag results compilation mode"
  (set (make-local-variable 'compilation-error-regexp-alist)
-       (list 'compilation-ag-nogroup))
+       '(compilation-ag-nogroup compilation-ag-group))
  (set (make-local-variable 'compilation-error-regexp-alist-alist)
-       (list (cons 'compilation-ag-nogroup (list ag/file-column-pattern 1 2 3))))
+       (list (cons 'compilation-ag-nogroup  (list ag/file-column-pattern-nogroup 1 2 3))
+             (cons 'compilation-ag-group  (list ag/file-column-pattern-group
+                                                'ag/compilation-match-grouped-filename 1 2))))
  (set (make-local-variable 'compilation-error-face) 'ag-hit-face)
  (set (make-local-variable 'next-error-function) #'ag/next-error-function)
  (set (make-local-variable 'compilation-finish-functions)
@ -158,7 +189,7 @@ different window, according to `ag-reuse-window'."

 (define-key ag-mode-map (kbd "p") #'compilation-previous-error)
 (define-key ag-mode-map (kbd "n") #'compilation-next-error)
-(define-key ag-mode-map (kbd "k") '(lambda () (interactive) 
+(define-key ag-mode-map (kbd "k") '(lambda () (interactive)
                                     (let (kill-buffer-query-functions) (kill-buffer))))

 (defun ag/buffer-name (search-string directory regexp)
@ -180,24 +211,30 @@ If REGEXP is non-nil, treat STRING as a regular expression."
  (let ((default-directory (file-name-as-directory directory))
        (arguments ag-arguments)
        (shell-command-switch "-c"))
+    ;; Add double dashes at the end of command line if not specified in
+    ;; ag-arguments.
+    (unless (equal (car (last arguments)) "--")
+      (setq arguments (append arguments '("--"))))
+    (setq arguments
+          (append '("--line-number" "--column" "--color" "--color-match" "30;43"
+                    "--color-path" "1;32")
+                  arguments))
+    (if ag-group-matches
+        (setq arguments (cons "--group" arguments))
+      (setq arguments (cons "--nogroup" arguments)))
    (unless regexp
      (setq arguments (cons "--literal" arguments)))
-    (if ag-highlight-search
-        ;; We're highlighting, so pass additional arguments for
-        ;; highlighting the current search term using shell escape
-        ;; sequences.
-        (setq arguments (append '("--color" "--color-match" "30;43") arguments))
-      ;; We're not highlighting.
-      (if (eq system-type 'windows-nt)
-          ;; Use --vimgrep to work around issue #97 on Windows.
-          (setq arguments (append '("--vimgrep") arguments))
-        (setq arguments (append '("--nocolor") arguments))))
+    (when (eq system-type 'windows-nt)
+      ;; Use --vimgrep to work around issue #97 on Windows.
+      (setq arguments (cons "--vimgrep" arguments)))
    (when (char-or-string-p file-regex)
      (setq arguments (append `("--file-search-regex" ,file-regex) arguments)))
    (when file-type
      (setq arguments (cons (format "--%s" file-type) arguments)))
-    (when (integerp current-prefix-arg)
-      (setq arguments (cons (format "--context=%d" (abs current-prefix-arg)) arguments)))
+    (if (integerp current-prefix-arg)
+        (setq arguments (cons (format "--context=%d" (abs current-prefix-arg)) arguments))
+      (when ag-context-lines
+        (setq arguments (cons (format "--context=%d" ag-context-lines) arguments))))
    (when ag-ignore-list
      (setq arguments (append (ag/format-ignore ag-ignore-list) arguments)))
    (unless (file-exists-p default-directory)
@ -385,7 +422,7 @@ matched literally."

 ;;;###autoload
 (defun ag (string directory)
-  "Search using ag in a given DIRECTORY for a given search STRING,
+  "Search using ag in a given DIRECTORY for a given literal search STRING,
 with STRING defaulting to the symbol under point.

 If called with a prefix, prompts for flags to pass to ag."
@ -395,9 +432,9 @@ If called with a prefix, prompts for flags to pass to ag."

 ;;;###autoload
 (defun ag-files (string file-type directory)
-  "Search using ag in a given DIRECTORY for a given search STRING,
-limited to files that match FILE-TYPE. STRING defaults to
-the symbol under point.
+  "Search using ag in a given DIRECTORY for a given literal search STRING,
+limited to files that match FILE-TYPE. STRING defaults to the
+symbol under point.

 If called with a prefix, prompts for flags to pass to ag."
  (interactive (list (ag/read-from-minibuffer "Search string")
@ -417,7 +454,7 @@ If called with a prefix, prompts for flags to pass to ag."
 ;;;###autoload
 (defun ag-project (string)
  "Guess the root of the current project and search it with ag
-for the given string.
+for the given literal search STRING.

 If called with a prefix, prompts for flags to pass to ag."
  (interactive (list (ag/read-from-minibuffer "Search string")))
@ -425,7 +462,7 @@ If called with a prefix, prompts for flags to pass to ag."

 ;;;###autoload
 (defun ag-project-files (string file-type)
-  "Search using ag for a given search STRING,
+  "Search using ag for a given literal search STRING,
 limited to files that match FILE-TYPE. STRING defaults to the
 symbol under point.

@ -474,8 +511,8 @@ If called with a prefix, prompts for flags to pass to ag."
 (make-obsolete 'ag-regexp-project-at-point 'ag-project-regexp "0.46")

 ;;;###autoload
-(defun ag-dired (dir pattern)
-  "Recursively find files in DIR matching PATTERN.
+(defun ag-dired (dir string)
+  "Recursively find files in DIR matching literal search STRING.

 The PATTERN is matched against the full path to the file, not
 only against the file name.
@ -485,7 +522,7 @@ The results are presented as a `dired-mode' buffer with

 See also `ag-dired-regexp'."
  (interactive "DDirectory: \nsFile pattern: ")
-  (ag-dired-regexp dir (ag/escape-pcre pattern)))
+  (ag-dired-regexp dir (ag/escape-pcre string)))

 ;;;###autoload
 (defun ag-dired-regexp (dir regexp)
@ -578,30 +615,39 @@ See also `ag-dired-regexp'."
             (not (eq buffer current-buffer)))
        (kill-buffer buffer)))))

-;; Taken from grep-filter, just changed the color regex.
+;; Based on grep-filter.
 (defun ag-filter ()
-  "Handle match highlighting escape sequences inserted by the ag process.
+  "Handle escape sequences inserted by the ag process.
 This function is called from `compilation-filter-hook'."
-  (when ag-highlight-search
-    (save-excursion
+  (save-excursion
+    (forward-line 0)
+    (let ((end (point)) beg)
+      (goto-char compilation-filter-start)
      (forward-line 0)
-      (let ((end (point)) beg)
-        (goto-char compilation-filter-start)
-        (forward-line 0)
-        (setq beg (point))
-        ;; Only operate on whole lines so we don't get caught with part of an
-        ;; escape sequence in one chunk and the rest in another.
-        (when (< (point) end)
-          (setq end (copy-marker end))
+      (setq beg (point))
+      ;; Only operate on whole lines so we don't get caught with part of an
+      ;; escape sequence in one chunk and the rest in another.
+      (when (< (point) end)
+        (setq end (copy-marker end))
+        (when ag-highlight-search
          ;; Highlight ag matches and delete marking sequences.
-          (while (re-search-forward "\033\\[30;43m\\(.*?\\)\033\\[[0-9]*m" end 1)
+          (while (re-search-forward "\033\\[30;43m\\(.*?\\)\033\\[0m\033\\[K" end 1)
            (replace-match (propertize (match-string 1)
                                       'face nil 'font-lock-face 'ag-match-face)
-                           t t))
-          ;; Delete all remaining escape sequences
+                           t t)))
+        ;; Add marker at start of line for files. This is used by the match
+        ;; in `compilation-error-regexp-alist' to extract the file name.
+        (when ag-group-matches
          (goto-char beg)
-          (while (re-search-forward "\033\\[[0-9;]*[mK]" end 1)
-            (replace-match "" t t)))))))
+          (while (re-search-forward "\033\\[1;32m\\(.*\\)\033\\[0m\033\\[K" end 1)
+            (replace-match
+             (concat "File: " (propertize (match-string 1) 'face nil 'font-lock-face
+                                          'compilation-info))
+             t t)))
+        ;; Delete all remaining escape sequences
+        (goto-char beg)
+        (while (re-search-forward "\033\\[[0-9;]*[mK]" end 1)
+          (replace-match "" t t))))))

 (defun ag/get-supported-types ()
  "Query the ag executable for which file types it recognises."
--- a/elpa/async-20160513.128/async-pkg.el
+++ b/elpa/async-20160513.128/async-pkg.el
@ -1,6 +0,0 @@
-(define-package "async" "20160513.128" "Asynchronous processing in Emacs" 'nil :keywords
-  '("async")
-  :url "http://elpa.gnu.org/packages/async.html")
-;; Local Variables:
-;; no-byte-compile: t
-;; End:
--- a/elpa/async-20160711.2235/async-autoloads.el
+++ b/elpa/async-20160711.2235/async-autoloads.el
@ -3,7 +3,7 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "async" "async.el" (22387 29376 289753 380000))
+;;;### (autoloads nil "async" "async.el" (22404 60275 161929 555000))
 ;;; Generated autoloads from async.el

 (autoload 'async-start-process "async" "\
@ -68,8 +68,8 @@ returns nil.  It can still be useful, however, as an argument to

 ;;;***

-;;;### (autoloads nil "async-bytecomp" "async-bytecomp.el" (22387
-;;;;;;  29376 281759 465000))
+;;;### (autoloads nil "async-bytecomp" "async-bytecomp.el" (22404
+;;;;;;  60275 153929 514000))
 ;;; Generated autoloads from async-bytecomp.el

 (autoload 'async-byte-recompile-directory "async-bytecomp" "\
@ -96,8 +96,8 @@ Async compilation of packages can be controlled by

 ;;;***

-;;;### (autoloads nil "dired-async" "dired-async.el" (22387 29376
-;;;;;;  261774 676000))
+;;;### (autoloads nil "dired-async" "dired-async.el" (22404 60275
+;;;;;;  137929 430000))
 ;;; Generated autoloads from dired-async.el

 (defvar dired-async-mode nil "\
@ -116,8 +116,8 @@ Do dired actions asynchronously.

 ;;;***

-;;;### (autoloads nil nil ("async-pkg.el" "smtpmail-async.el") (22387
-;;;;;;  29376 315816 570000))
+;;;### (autoloads nil nil ("async-pkg.el" "smtpmail-async.el") (22404
+;;;;;;  60275 190952 741000))

 ;;;***

--- a/elpa/async-20160711.2235/async-bytecomp.el
+++ b/elpa/async-20160711.2235/async-bytecomp.el
--- a/elpa/async-20160711.2235/async-pkg.el
+++ b/elpa/async-20160711.2235/async-pkg.el
@ -0,0 +1,6 @@
+(define-package "async" "20160711.2235" "Asynchronous processing in Emacs" 'nil :keywords
+  '("async")
+  :url "https://github.com/jwiegley/emacs-async")
+;; Local Variables:
+;; no-byte-compile: t
+;; End:
--- a/elpa/async-20160711.2235/async.el
+++ b/elpa/async-20160711.2235/async.el
--- a/elpa/async-20160711.2235/dired-async.el
+++ b/elpa/async-20160711.2235/dired-async.el
--- a/elpa/async-20160711.2235/smtpmail-async.el
+++ b/elpa/async-20160711.2235/smtpmail-async.el
--- a/elpa/company-20160709.1536/company-abbrev.el
+++ b/elpa/company-20160709.1536/company-abbrev.el
--- a/elpa/company-20160709.1536/company-autoloads.el
+++ b/elpa/company-20160709.1536/company-autoloads.el
@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "company" "company.el" (22387 29374 119407
-;;;;;;  928000))
+;;;### (autoloads nil "company" "company.el" (22404 60273 313919
+;;;;;;  883000))
 ;;; Generated autoloads from company.el

 (autoload 'company-mode "company" "\
@ -73,8 +73,8 @@ inserted.

 ;;;***

-;;;### (autoloads nil "company-abbrev" "company-abbrev.el" (22387
-;;;;;;  29374 199346 932000))
+;;;### (autoloads nil "company-abbrev" "company-abbrev.el" (22404
+;;;;;;  60273 385920 259000))
 ;;; Generated autoloads from company-abbrev.el

 (autoload 'company-abbrev "company-abbrev" "\
@ -84,8 +84,8 @@ inserted.

 ;;;***

-;;;### (autoloads nil "company-bbdb" "company-bbdb.el" (22387 29374
-;;;;;;  179362 181000))
+;;;### (autoloads nil "company-bbdb" "company-bbdb.el" (22404 60273
+;;;;;;  369920 176000))
 ;;; Generated autoloads from company-bbdb.el

 (autoload 'company-bbdb "company-bbdb" "\
@ -95,8 +95,8 @@ inserted.

 ;;;***

-;;;### (autoloads nil "company-css" "company-css.el" (22387 29374
-;;;;;;  115410 979000))
+;;;### (autoloads nil "company-css" "company-css.el" (22404 60273
+;;;;;;  305919 841000))
 ;;; Generated autoloads from company-css.el

 (autoload 'company-css "company-css" "\
@ -106,8 +106,8 @@ inserted.

 ;;;***

-;;;### (autoloads nil "company-dabbrev" "company-dabbrev.el" (22387
-;;;;;;  29374 151383 530000))
+;;;### (autoloads nil "company-dabbrev" "company-dabbrev.el" (22404
+;;;;;;  60273 337920 9000))
 ;;; Generated autoloads from company-dabbrev.el

 (autoload 'company-dabbrev "company-dabbrev" "\
@ -118,7 +118,7 @@ dabbrev-like `company-mode' completion backend.
 ;;;***

 ;;;### (autoloads nil "company-dabbrev-code" "company-dabbrev-code.el"
-;;;;;;  (22387 29374 139392 679000))
+;;;;;;  (22404 60273 329919 967000))
 ;;; Generated autoloads from company-dabbrev-code.el

 (autoload 'company-dabbrev-code "company-dabbrev-code" "\
@ -130,8 +130,8 @@ comments or strings.

 ;;;***

-;;;### (autoloads nil "company-elisp" "company-elisp.el" (22387 29374
-;;;;;;  207340 832000))
+;;;### (autoloads nil "company-elisp" "company-elisp.el" (22404 60273
+;;;;;;  397920 322000))
 ;;; Generated autoloads from company-elisp.el

 (autoload 'company-elisp "company-elisp" "\
@ -141,8 +141,8 @@ comments or strings.

 ;;;***

-;;;### (autoloads nil "company-etags" "company-etags.el" (22387 29374
-;;;;;;  127401 829000))
+;;;### (autoloads nil "company-etags" "company-etags.el" (22404 60273
+;;;;;;  321919 925000))
 ;;; Generated autoloads from company-etags.el

 (autoload 'company-etags "company-etags" "\
@ -152,8 +152,8 @@ comments or strings.

 ;;;***

-;;;### (autoloads nil "company-files" "company-files.el" (22387 29374
-;;;;;;  159377 430000))
+;;;### (autoloads nil "company-files" "company-files.el" (22404 60273
+;;;;;;  341920 29000))
 ;;; Generated autoloads from company-files.el

 (autoload 'company-files "company-files" "\
@ -165,8 +165,8 @@ File paths with spaces are only supported inside strings.

 ;;;***

-;;;### (autoloads nil "company-gtags" "company-gtags.el" (22387 29374
-;;;;;;  87432 327000))
+;;;### (autoloads nil "company-gtags" "company-gtags.el" (22404 60273
+;;;;;;  277919 694000))
 ;;; Generated autoloads from company-gtags.el

 (autoload 'company-gtags "company-gtags" "\
@ -176,8 +176,8 @@ File paths with spaces are only supported inside strings.

 ;;;***

-;;;### (autoloads nil "company-ispell" "company-ispell.el" (22387
-;;;;;;  29374 203343 882000))
+;;;### (autoloads nil "company-ispell" "company-ispell.el" (22404
+;;;;;;  60273 393920 301000))
 ;;; Generated autoloads from company-ispell.el

 (autoload 'company-ispell "company-ispell" "\
@ -187,8 +187,8 @@ File paths with spaces are only supported inside strings.

 ;;;***

-;;;### (autoloads nil "company-keywords" "company-keywords.el" (22387
-;;;;;;  29374 167371 330000))
+;;;### (autoloads nil "company-keywords" "company-keywords.el" (22404
+;;;;;;  60273 353920 92000))
 ;;; Generated autoloads from company-keywords.el

 (autoload 'company-keywords "company-keywords" "\
@ -198,8 +198,8 @@ File paths with spaces are only supported inside strings.

 ;;;***

-;;;### (autoloads nil "company-nxml" "company-nxml.el" (22387 29374
-;;;;;;  187356 81000))
+;;;### (autoloads nil "company-nxml" "company-nxml.el" (22404 60273
+;;;;;;  373920 196000))
 ;;; Generated autoloads from company-nxml.el

 (autoload 'company-nxml "company-nxml" "\
@ -209,8 +209,8 @@ File paths with spaces are only supported inside strings.

 ;;;***

-;;;### (autoloads nil "company-oddmuse" "company-oddmuse.el" (22387
-;;;;;;  29374 107417 78000))
+;;;### (autoloads nil "company-oddmuse" "company-oddmuse.el" (22404
+;;;;;;  60273 285919 736000))
 ;;; Generated autoloads from company-oddmuse.el

 (autoload 'company-oddmuse "company-oddmuse" "\
@ -220,8 +220,8 @@ File paths with spaces are only supported inside strings.

 ;;;***

-;;;### (autoloads nil "company-semantic" "company-semantic.el" (22387
-;;;;;;  29374 91429 277000))
+;;;### (autoloads nil "company-semantic" "company-semantic.el" (22404
+;;;;;;  60273 277919 694000))
 ;;; Generated autoloads from company-semantic.el

 (autoload 'company-semantic "company-semantic" "\
@ -231,8 +231,8 @@ File paths with spaces are only supported inside strings.

 ;;;***

-;;;### (autoloads nil "company-tempo" "company-tempo.el" (22387 29374
-;;;;;;  147386 580000))
+;;;### (autoloads nil "company-tempo" "company-tempo.el" (22404 60273
+;;;;;;  333919 988000))
 ;;; Generated autoloads from company-tempo.el

 (autoload 'company-tempo "company-tempo" "\
@ -242,8 +242,8 @@ File paths with spaces are only supported inside strings.

 ;;;***

-;;;### (autoloads nil "company-xcode" "company-xcode.el" (22387 29374
-;;;;;;  195349 982000))
+;;;### (autoloads nil "company-xcode" "company-xcode.el" (22404 60273
+;;;;;;  381920 238000))
 ;;; Generated autoloads from company-xcode.el

 (autoload 'company-xcode "company-xcode" "\
@ -254,7 +254,7 @@ File paths with spaces are only supported inside strings.
 ;;;***

 ;;;### (autoloads nil "company-yasnippet" "company-yasnippet.el"
-;;;;;;  (22387 29374 191353 32000))
+;;;;;;  (22404 60273 377920 217000))
 ;;; Generated autoloads from company-yasnippet.el

 (autoload 'company-yasnippet "company-yasnippet" "\
@ -286,7 +286,7 @@ shadow backends that come after it.  Recommended usages:

 ;;;### (autoloads nil nil ("company-capf.el" "company-clang.el" "company-cmake.el"
 ;;;;;;  "company-eclim.el" "company-pkg.el" "company-template.el")
-;;;;;;  (22387 29374 220274 120000))
+;;;;;;  (22404 60273 409561 422000))

 ;;;***

--- a/elpa/company-20160709.1536/company-bbdb.el
+++ b/elpa/company-20160709.1536/company-bbdb.el
--- a/elpa/company-20160709.1536/company-capf.el
+++ b/elpa/company-20160709.1536/company-capf.el
--- a/elpa/company-20160709.1536/company-clang.el
+++ b/elpa/company-20160709.1536/company-clang.el
--- a/elpa/company-20160709.1536/company-cmake.el
+++ b/elpa/company-20160709.1536/company-cmake.el
--- a/elpa/company-20160709.1536/company-css.el
+++ b/elpa/company-20160709.1536/company-css.el
--- a/elpa/company-20160709.1536/company-dabbrev-code.el
+++ b/elpa/company-20160709.1536/company-dabbrev-code.el
--- a/elpa/company-20160709.1536/company-dabbrev.el
+++ b/elpa/company-20160709.1536/company-dabbrev.el
--- a/elpa/company-20160709.1536/company-eclim.el
+++ b/elpa/company-20160709.1536/company-eclim.el
--- a/elpa/company-20160709.1536/company-elisp.el
+++ b/elpa/company-20160709.1536/company-elisp.el
--- a/elpa/company-20160709.1536/company-etags.el
+++ b/elpa/company-20160709.1536/company-etags.el
--- a/elpa/company-20160709.1536/company-files.el
+++ b/elpa/company-20160709.1536/company-files.el
@ -1,4 +1,4 @@
-;;; company-files.el --- company-mode completion backend for file paths
+;;; company-files.el --- company-mode completion backend for file names

 ;; Copyright (C) 2009-2011, 2014-2015  Free Software Foundation, Inc.

@ -28,14 +28,38 @@
 (require 'company)
 (require 'cl-lib)

+(defgroup company-files nil
+  "Completion backend for file names."
+  :group 'company)
+
+(defcustom company-files-exclusions nil
+  "File name extensions and directory names to ignore.
+The values should use the same format as `completion-ignored-extensions'."
+  :type '(const string)
+  :package-version '(company . "0.9.1"))
+
 (defun company-files--directory-files (dir prefix)
-  (ignore-errors
-    ;; Don't use directory-files. It produces directories without trailing /.
-    (let ((comp (sort (file-name-all-completions prefix dir)
-                      (lambda (s1 s2) (string-lessp (downcase s1) (downcase s2))))))
-      (if (equal prefix "")
-          (delete "../" (delete "./" comp))
-        comp))))
+  ;; Don't use directory-files. It produces directories without trailing /.
+  (let ((comp (sort (file-name-all-completions prefix dir)
+                    (lambda (s1 s2) (string-lessp (downcase s1) (downcase s2))))))
+    (when company-files-exclusions
+      (setq comp (company-files--exclusions-filtered comp)))
+    (if (equal prefix "")
+        (delete "../" (delete "./" comp))
+      comp)))
+
+(defun company-files--exclusions-filtered (completions)
+  (let* ((dir-exclusions (cl-delete-if-not #'company-files--trailing-slash-p
+                                           company-files-exclusions))
+         (file-exclusions (cl-set-difference company-files-exclusions
+                                             dir-exclusions)))
+    (cl-loop for c in completions
+             unless (if (company-files--trailing-slash-p c)
+                        (member c dir-exclusions)
+                      (cl-find-if (lambda (exclusion)
+                                    (string-suffix-p exclusion c))
+                                  file-exclusions))
+             collect c)))

 (defvar company-files--regexps
  (let* ((root (if (eq system-type 'windows-nt)
--- a/elpa/company-20160709.1536/company-gtags.el
+++ b/elpa/company-20160709.1536/company-gtags.el
--- a/elpa/company-20160709.1536/company-ispell.el
+++ b/elpa/company-20160709.1536/company-ispell.el
--- a/elpa/company-20160709.1536/company-keywords.el
+++ b/elpa/company-20160709.1536/company-keywords.el
--- a/elpa/company-20160709.1536/company-nxml.el
+++ b/elpa/company-20160709.1536/company-nxml.el
--- a/elpa/company-20160709.1536/company-oddmuse.el
+++ b/elpa/company-20160709.1536/company-oddmuse.el
--- a/elpa/company-20160709.1536/company-pkg.el
+++ b/elpa/company-20160709.1536/company-pkg.el
@ -1,4 +1,4 @@
-(define-package "company" "20160626.1903" "Modular text completion framework"
+(define-package "company" "20160709.1536" "Modular text completion framework"
  '((emacs "24.1")
    (cl-lib "0.5"))
  :url "http://company-mode.github.io/" :keywords
--- a/elpa/company-20160709.1536/company-semantic.el
+++ b/elpa/company-20160709.1536/company-semantic.el
--- a/elpa/company-20160709.1536/company-template.el
+++ b/elpa/company-20160709.1536/company-template.el
--- a/elpa/company-20160709.1536/company-tempo.el
+++ b/elpa/company-20160709.1536/company-tempo.el
--- a/elpa/company-20160709.1536/company-xcode.el
+++ b/elpa/company-20160709.1536/company-xcode.el
--- a/elpa/company-20160709.1536/company-yasnippet.el
+++ b/elpa/company-20160709.1536/company-yasnippet.el
--- a/elpa/company-20160709.1536/company.el
+++ b/elpa/company-20160709.1536/company.el
@ -83,7 +83,17 @@ buffer-local wherever it is set."
      (declare (debug defvar) (doc-string 3))
      `(progn
         (defvar ,var ,val ,docstring)
-         (make-variable-buffer-local ',var)))))
+         (make-variable-buffer-local ',var))))
+
+  (unless (fboundp 'string-suffix-p)
+    (defun string-suffix-p (suffix string  &optional ignore-case)
+      "Return non-nil if SUFFIX is a suffix of STRING.
+If IGNORE-CASE is non-nil, the comparison is done without paying
+attention to case differences."
+      (let ((start-pos (- (length string) (length suffix))))
+        (and (>= start-pos 0)
+             (eq t (compare-strings suffix nil nil
+                                    string start-pos nil ignore-case)))))))

 (defgroup company nil
  "Extensible inline text completion mechanism"
--- a/elpa/git-gutter-20160702.354/git-gutter-autoloads.el
+++ b/elpa/git-gutter-20160702.354/git-gutter-autoloads.el
@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "git-gutter" "git-gutter.el" (22387 29368 367814
-;;;;;;  765000))
+;;;### (autoloads nil "git-gutter" "git-gutter.el" (22404 60266 753885
+;;;;;;  560000))
 ;;; Generated autoloads from git-gutter.el

 (autoload 'git-gutter:linum-setup "git-gutter" "\
--- a/elpa/git-gutter-20160702.354/git-gutter-pkg.el
+++ b/elpa/git-gutter-20160702.354/git-gutter-pkg.el
@ -1 +1 @@
-(define-package "git-gutter" "20160610.852" "Port of Sublime Text plugin GitGutter" '((cl-lib "0.5") (emacs "24")) :url "https://github.com/syohex/emacs-git-gutter")
+(define-package "git-gutter" "20160702.354" "Port of Sublime Text plugin GitGutter" '((cl-lib "0.5") (emacs "24")) :url "https://github.com/syohex/emacs-git-gutter")
--- a/elpa/git-gutter-20160702.354/git-gutter.el
+++ b/elpa/git-gutter-20160702.354/git-gutter.el
@ -4,7 +4,7 @@

 ;; Author: Syohei YOSHIDA <syohex@gmail.com>
 ;; URL: https://github.com/syohex/emacs-git-gutter
-;; Package-Version: 20160610.852
+;; Package-Version: 20160702.354
 ;; Version: 0.89
 ;; Package-Requires: ((cl-lib "0.5") (emacs "24"))

@ -170,6 +170,10 @@ gutter information of other windows."
  "Ask whether commit/revert or not"
  :type 'boolean)

+(defcustom git-gutter:display-p t
+  "Display diff information or not."
+  :type 'boolean)
+
 (cl-defstruct git-gutter-hunk
  type content start-line end-line)

@ -509,12 +513,13 @@ gutter information of other windows."
  (setq git-gutter:init-function 'git-gutter:linum-init
        git-gutter:view-diff-function nil)
  (defadvice linum-update-window (after git-gutter:linum-update-window activate)
-    (if (and git-gutter-mode git-gutter:diffinfos)
-        (git-gutter:linum-update git-gutter:diffinfos)
-      (let ((curwin (get-buffer-window))
-            (margin (or git-gutter:linum-prev-window-margin
-                        (car (window-margins)))))
-        (set-window-margins curwin margin (cdr (window-margins curwin)))))))
+    (when git-gutter:display-p
+      (if (and git-gutter-mode git-gutter:diffinfos)
+          (git-gutter:linum-update git-gutter:diffinfos)
+        (let ((curwin (get-buffer-window))
+              (margin (or git-gutter:linum-prev-window-margin
+                          (car (window-margins)))))
+          (set-window-margins curwin margin (cdr (window-margins curwin))))))))

 (defun git-gutter:show-backends ()
  (mapconcat (lambda (backend)
@ -631,7 +636,7 @@ gutter information of other windows."
    (widen)
    (git-gutter:clear-gutter)
    (setq git-gutter:diffinfos diffinfos)
-    (when git-gutter:view-diff-function
+    (when (and git-gutter:display-p git-gutter:view-diff-function)
      (funcall git-gutter:view-diff-function diffinfos))))

 (defun git-gutter:search-near-diff-index (diffinfos is-reverse)
--- a/elpa/gitconfig-mode-20160319.302/gitconfig-mode-pkg.el
+++ b/elpa/gitconfig-mode-20160319.302/gitconfig-mode-pkg.el
@ -1 +0,0 @@
-(define-package "gitconfig-mode" "20160319.302" "Major mode for editing .gitconfig files" 'nil :url "https://github.com/magit/git-modes" :keywords '("convenience" "vc" "git"))
--- a/elpa/gitconfig-mode-20160710.1913/gitconfig-mode-autoloads.el
+++ b/elpa/gitconfig-mode-20160710.1913/gitconfig-mode-autoloads.el
@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "gitconfig-mode" "gitconfig-mode.el" (22297
-;;;;;;  19828 264884 774000))
+;;;### (autoloads nil "gitconfig-mode" "gitconfig-mode.el" (22404
+;;;;;;  60264 981876 293000))
 ;;; Generated autoloads from gitconfig-mode.el

 (autoload 'gitconfig-mode "gitconfig-mode" "\
--- a/elpa/gitconfig-mode-20160710.1913/gitconfig-mode-pkg.el
+++ b/elpa/gitconfig-mode-20160710.1913/gitconfig-mode-pkg.el
@ -0,0 +1 @@
+(define-package "gitconfig-mode" "20160710.1913" "Major mode for editing .gitconfig files" 'nil :url "https://github.com/magit/git-modes" :keywords '("convenience" "vc" "git"))
--- a/elpa/gitconfig-mode-20160710.1913/gitconfig-mode.el
+++ b/elpa/gitconfig-mode-20160710.1913/gitconfig-mode.el
@ -7,7 +7,7 @@
 ;; Maintainer: Jonas Bernoulli <jonas@bernoul.li>
 ;; Homepage: https://github.com/magit/git-modes
 ;; Keywords: convenience vc git
-;; Package-Version: 20160319.302
+;; Package-Version: 20160710.1913

 ;; This file is not part of GNU Emacs.

@ -99,7 +99,8 @@
     (1 'font-lock-type-face t nil)
     (2 'font-lock-function-name-face t t))
    (,(rx line-start (zero-or-more (syntax whitespace)) symbol-start
-          (group (one-or-more (or (syntax word) (syntax symbol))))
+          (group alphanumeric
+                 (zero-or-more (or (syntax word) (syntax symbol))))
          symbol-end (zero-or-more (syntax whitespace))
          (optional "=" (zero-or-more not-newline)) line-end)
     (1 'font-lock-variable-name-face))
--- a/elpa/helm-20160711.1143/emacs-helm.sh
+++ b/elpa/helm-20160711.1143/emacs-helm.sh
--- a/elpa/helm-20160711.1143/helm-adaptive.el
+++ b/elpa/helm-20160711.1143/helm-adaptive.el
@ -80,13 +80,7 @@ Format: ((SOURCE-NAME (SELECTED-CANDIDATE (PATTERN . NUMBER-OF-USE) ...) ...) ..
  "Return current source only if it use adaptive history, nil otherwise."
  (when helm-adaptive-mode
    (let* ((source (or source-name (helm-get-current-source)))
-           (adapt-source (or (assoc-default 'filtered-candidate-transformer
-                                            (assoc (assoc-default 'type source)
-                                                   helm-type-attributes))
-                             (assoc-default 'candidate-transformer
-                                            (assoc (assoc-default 'type source)
-                                                   helm-type-attributes))
-                             (assoc-default 'filtered-candidate-transformer source)
+           (adapt-source (or (assoc-default 'filtered-candidate-transformer source)
                             (assoc-default 'candidate-transformer source))))
      (if (listp adapt-source)
          (and (member 'helm-adaptive-sort adapt-source) source)
--- a/elpa/helm-20160711.1143/helm-apt.el
+++ b/elpa/helm-20160711.1143/helm-apt.el
--- a/elpa/helm-20160711.1143/helm-autoloads.el
+++ b/elpa/helm-20160711.1143/helm-autoloads.el
@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "helm-adaptive" "helm-adaptive.el" (22387 29367
-;;;;;;  188722 114000))
+;;;### (autoloads nil "helm-adaptive" "helm-adaptive.el" (22404 60264
+;;;;;;  321872 842000))
 ;;; Generated autoloads from helm-adaptive.el

 (defvar helm-adaptive-mode nil "\
@ -29,8 +29,8 @@ Useful when you have a old or corrupted `helm-adaptive-history-file'.

 ;;;***

-;;;### (autoloads nil "helm-apt" "helm-apt.el" (22387 29367 144755
-;;;;;;  961000))
+;;;### (autoloads nil "helm-apt" "helm-apt.el" (22404 60264 293872
+;;;;;;  696000))
 ;;; Generated autoloads from helm-apt.el

 (autoload 'helm-apt "helm-apt" "\
@ -41,8 +41,8 @@ With a prefix arg reload cache.

 ;;;***

-;;;### (autoloads nil "helm-bookmark" "helm-bookmark.el" (22387 29367
-;;;;;;  236685 191000))
+;;;### (autoloads nil "helm-bookmark" "helm-bookmark.el" (22404 60264
+;;;;;;  389873 198000))
 ;;; Generated autoloads from helm-bookmark.el

 (autoload 'helm-bookmarks "helm-bookmark" "\
@ -59,8 +59,8 @@ only if external library addressbook-bookmark.el is available.

 ;;;***

-;;;### (autoloads nil "helm-buffers" "helm-buffers.el" (22387 29367
-;;;;;;  132765 192000))
+;;;### (autoloads nil "helm-buffers" "helm-buffers.el" (22404 60264
+;;;;;;  281872 633000))
 ;;; Generated autoloads from helm-buffers.el

 (autoload 'helm-buffers-list "helm-buffers" "\
@ -75,8 +75,8 @@ Preconfigured `helm' lightweight version (buffer -> recentf).

 ;;;***

-;;;### (autoloads nil "helm-color" "helm-color.el" (22387 29367 220697
-;;;;;;  499000))
+;;;### (autoloads nil "helm-color" "helm-color.el" (22404 60264 373873
+;;;;;;  114000))
 ;;; Generated autoloads from helm-color.el

 (autoload 'helm-colors "helm-color" "\
@ -86,8 +86,8 @@ Preconfigured `helm' for color.

 ;;;***

-;;;### (autoloads nil "helm-command" "helm-command.el" (22387 29367
-;;;;;;  76808 270000))
+;;;### (autoloads nil "helm-command" "helm-command.el" (22404 60264
+;;;;;;  229872 361000))
 ;;; Generated autoloads from helm-command.el

 (autoload 'helm-M-x "helm-command" "\
@ -105,8 +105,8 @@ You can get help on each command by persistent action.

 ;;;***

-;;;### (autoloads nil "helm-config" "helm-config.el" (22387 29367
-;;;;;;  228691 345000))
+;;;### (autoloads nil "helm-config" "helm-config.el" (22404 60264
+;;;;;;  385873 177000))
 ;;; Generated autoloads from helm-config.el

 (autoload 'helm-configuration "helm-config" "\
@ -116,8 +116,8 @@ Customize `helm'.

 ;;;***

-;;;### (autoloads nil "helm-dabbrev" "helm-dabbrev.el" (22387 29367
-;;;;;;  156746 731000))
+;;;### (autoloads nil "helm-dabbrev" "helm-dabbrev.el" (22404 60264
+;;;;;;  301872 738000))
 ;;; Generated autoloads from helm-dabbrev.el

 (autoload 'helm-dabbrev "helm-dabbrev" "\
@ -127,8 +127,8 @@ Preconfigured helm for dynamic abbreviations.

 ;;;***

-;;;### (autoloads nil "helm-elisp" "helm-elisp.el" (22387 29367 224694
-;;;;;;  422000))
+;;;### (autoloads nil "helm-elisp" "helm-elisp.el" (22404 60264 381873
+;;;;;;  156000))
 ;;; Generated autoloads from helm-elisp.el

 (autoload 'helm-lisp-completion-at-point "helm-elisp" "\
@ -182,7 +182,7 @@ Preconfigured helm for complex command history.
 ;;;***

 ;;;### (autoloads nil "helm-elisp-package" "helm-elisp-package.el"
-;;;;;;  (22387 29367 80805 193000))
+;;;;;;  (22404 60264 237872 403000))
 ;;; Generated autoloads from helm-elisp-package.el

 (autoload 'helm-list-elisp-packages "helm-elisp-package" "\
@ -198,8 +198,8 @@ Same as `helm-list-elisp-packages' but don't fetch packages on remote.

 ;;;***

-;;;### (autoloads nil "helm-elscreen" "helm-elscreen.el" (22387 29367
-;;;;;;  68814 424000))
+;;;### (autoloads nil "helm-elscreen" "helm-elscreen.el" (22404 60264
+;;;;;;  217872 298000))
 ;;; Generated autoloads from helm-elscreen.el

 (autoload 'helm-elscreen "helm-elscreen" "\
@ -214,8 +214,8 @@ Preconfigured helm to list elscreen in history order.

 ;;;***

-;;;### (autoloads nil "helm-eshell" "helm-eshell.el" (22387 29367
-;;;;;;  100789 808000))
+;;;### (autoloads nil "helm-eshell" "helm-eshell.el" (22404 60264
+;;;;;;  249872 465000))
 ;;; Generated autoloads from helm-eshell.el

 (autoload 'helm-esh-pcomplete "helm-eshell" "\
@ -230,8 +230,8 @@ Preconfigured helm for eshell history.

 ;;;***

-;;;### (autoloads nil "helm-eval" "helm-eval.el" (22387 29367 196715
-;;;;;;  961000))
+;;;### (autoloads nil "helm-eval" "helm-eval.el" (22404 60264 345872
+;;;;;;  967000))
 ;;; Generated autoloads from helm-eval.el

 (autoload 'helm-eval-expression "helm-eval" "\
@ -251,8 +251,8 @@ Preconfigured helm for `helm-source-calculation-result'.

 ;;;***

-;;;### (autoloads nil "helm-external" "helm-external.el" (22387 29367
-;;;;;;  56823 655000))
+;;;### (autoloads nil "helm-external" "helm-external.el" (22404 60264
+;;;;;;  197872 194000))
 ;;; Generated autoloads from helm-external.el

 (autoload 'helm-run-external-command "helm-external" "\
@ -265,8 +265,8 @@ You can set your own list of commands with

 ;;;***

-;;;### (autoloads nil "helm-files" "helm-files.el" (22387 29367 172734
-;;;;;;  423000))
+;;;### (autoloads nil "helm-files" "helm-files.el" (22404 60264 305872
+;;;;;;  759000))
 ;;; Generated autoloads from helm-files.el

 (autoload 'helm-browse-project "helm-files" "\
@ -339,8 +339,8 @@ Preconfigured `helm' for `recentf'.

 ;;;***

-;;;### (autoloads nil "helm-font" "helm-font.el" (22387 29367 104786
-;;;;;;  731000))
+;;;### (autoloads nil "helm-font" "helm-font.el" (22404 60264 257872
+;;;;;;  507000))
 ;;; Generated autoloads from helm-font.el

 (autoload 'helm-select-xfont "helm-font" "\
@ -355,8 +355,8 @@ Preconfigured helm for `ucs-names' math symbols.

 ;;;***

-;;;### (autoloads nil "helm-grep" "helm-grep.el" (22387 29367 240682
-;;;;;;  114000))
+;;;### (autoloads nil "helm-grep" "helm-grep.el" (22404 60264 397873
+;;;;;;  239000))
 ;;; Generated autoloads from helm-grep.el

 (autoload 'helm-goto-precedent-file "helm-grep" "\
@ -383,8 +383,8 @@ With a prefix arg ARG git-grep the whole repository.

 ;;;***

-;;;### (autoloads nil "helm-help" "helm-help.el" (22387 29367 52826
-;;;;;;  733000))
+;;;### (autoloads nil "helm-help" "helm-help.el" (22404 60264 193872
+;;;;;;  173000))
 ;;; Generated autoloads from helm-help.el

 (autoload 'helm-documentation "helm-help" "\
@ -402,16 +402,10 @@ String displayed in mode-line in `helm-source-find-files'.")

 (defvar helm-top-mode-line "\\<helm-top-map>\\[helm-help]:Help \\<helm-map>\\[helm-select-action]:Act \\[helm-maybe-exit-minibuffer]/f1/f2/f-n:NthAct \\[helm-toggle-suspend-update]:Tog.suspend")

-(autoload 'helm-describe-helm-attribute "helm-help" "\
-Display the full documentation of HELM-ATTRIBUTE.
-HELM-ATTRIBUTE should be a symbol.
-
-\(fn HELM-ATTRIBUTE)" t nil)
-
 ;;;***

-;;;### (autoloads nil "helm-id-utils" "helm-id-utils.el" (22387 29367
-;;;;;;  140759 38000))
+;;;### (autoloads nil "helm-id-utils" "helm-id-utils.el" (22404 60264
+;;;;;;  285872 654000))
 ;;; Generated autoloads from helm-id-utils.el

 (autoload 'helm-gid "helm-id-utils" "\
@ -425,8 +419,8 @@ See <https://www.gnu.org/software/idutils/>.

 ;;;***

-;;;### (autoloads nil "helm-imenu" "helm-imenu.el" (22387 29367 120774
-;;;;;;  423000))
+;;;### (autoloads nil "helm-imenu" "helm-imenu.el" (22404 60264 273872
+;;;;;;  591000))
 ;;; Generated autoloads from helm-imenu.el

 (autoload 'helm-imenu "helm-imenu" "\
@ -443,8 +437,8 @@ or it have an association in `helm-imenu-all-buffer-assoc'.

 ;;;***

-;;;### (autoloads nil "helm-info" "helm-info.el" (22387 29367 112780
-;;;;;;  578000))
+;;;### (autoloads nil "helm-info" "helm-info.el" (22404 60264 261872
+;;;;;;  528000))
 ;;; Generated autoloads from helm-info.el

 (autoload 'helm-info "helm-info" "\
@ -460,8 +454,8 @@ With a prefix-arg insert symbol at point.

 ;;;***

-;;;### (autoloads nil "helm-locate" "helm-locate.el" (22387 29367
-;;;;;;  60820 578000))
+;;;### (autoloads nil "helm-locate" "helm-locate.el" (22404 60264
+;;;;;;  209872 256000))
 ;;; Generated autoloads from helm-locate.el

 (autoload 'helm-projects-find-files "helm-locate" "\
@ -488,8 +482,8 @@ Where db_path is a filename matched by

 ;;;***

-;;;### (autoloads nil "helm-man" "helm-man.el" (22387 29367 200712
-;;;;;;  884000))
+;;;### (autoloads nil "helm-man" "helm-man.el" (22404 60264 349872
+;;;;;;  988000))
 ;;; Generated autoloads from helm-man.el

 (autoload 'helm-man-woman "helm-man" "\
@ -500,8 +494,8 @@ With a prefix arg reinitialize the cache.

 ;;;***

-;;;### (autoloads nil "helm-misc" "helm-misc.el" (22387 29367 180728
-;;;;;;  268000))
+;;;### (autoloads nil "helm-misc" "helm-misc.el" (22404 60264 317872
+;;;;;;  821000))
 ;;; Generated autoloads from helm-misc.el

 (autoload 'helm-browse-menubar "helm-misc" "\
@ -542,8 +536,8 @@ Preconfigured `helm' that provide completion of `comint' history.

 ;;;***

-;;;### (autoloads nil "helm-mode" "helm-mode.el" (22387 29366 904940
-;;;;;;  675000))
+;;;### (autoloads nil "helm-mode" "helm-mode.el" (22404 60264 185872
+;;;;;;  131000))
 ;;; Generated autoloads from helm-mode.el

 (autoload 'helm-comp-read "helm-mode" "\
@ -710,8 +704,8 @@ Note: This mode is incompatible with Emacs23.

 ;;;***

-;;;### (autoloads nil "helm-net" "helm-net.el" (22387 29367 216700
-;;;;;;  576000))
+;;;### (autoloads nil "helm-net" "helm-net.el" (22404 60264 369873
+;;;;;;  93000))
 ;;; Generated autoloads from helm-net.el

 (autoload 'helm-surfraw "helm-net" "\
@ -731,8 +725,8 @@ Preconfigured `helm' for Wikipedia lookup with Wikipedia suggest.

 ;;;***

-;;;### (autoloads nil "helm-org" "helm-org.el" (22387 29367 244679
-;;;;;;  37000))
+;;;### (autoloads nil "helm-org" "helm-org.el" (22404 60264 401873
+;;;;;;  260000))
 ;;; Generated autoloads from helm-org.el

 (autoload 'helm-org-agenda-files-headings "helm-org" "\
@ -763,8 +757,8 @@ Preconfigured helm for org templates.

 ;;;***

-;;;### (autoloads nil "helm-regexp" "helm-regexp.el" (22387 29367
-;;;;;;  208706 730000))
+;;;### (autoloads nil "helm-regexp" "helm-regexp.el" (22404 60264
+;;;;;;  361873 51000))
 ;;; Generated autoloads from helm-regexp.el

 (autoload 'helm-moccur-mode "helm-regexp" "\
@ -803,8 +797,8 @@ The prefix arg can be set before calling

 ;;;***

-;;;### (autoloads nil "helm-ring" "helm-ring.el" (22387 29367 48829
-;;;;;;  810000))
+;;;### (autoloads nil "helm-ring" "helm-ring.el" (22404 60264 189872
+;;;;;;  152000))
 ;;; Generated autoloads from helm-ring.el

 (defvar helm-push-mark-mode nil "\
@ -861,8 +855,8 @@ This command is useful when used with persistent action.

 ;;;***

-;;;### (autoloads nil "helm-semantic" "helm-semantic.el" (22387 29367
-;;;;;;  128768 269000))
+;;;### (autoloads nil "helm-semantic" "helm-semantic.el" (22404 60264
+;;;;;;  277872 612000))
 ;;; Generated autoloads from helm-semantic.el

 (autoload 'helm-semantic "helm-semantic" "\
@ -884,8 +878,8 @@ Fill in the symbol at point by default.

 ;;;***

-;;;### (autoloads nil "helm-sys" "helm-sys.el" (22387 29367 148752
-;;;;;;  884000))
+;;;### (autoloads nil "helm-sys" "helm-sys.el" (22404 60264 297872
+;;;;;;  717000))
 ;;; Generated autoloads from helm-sys.el

 (defvar helm-top-poll-mode nil "\
@ -919,8 +913,8 @@ Preconfigured helm for xrandr.

 ;;;***

-;;;### (autoloads nil "helm-tags" "helm-tags.el" (22387 29367 92795
-;;;;;;  962000))
+;;;### (autoloads nil "helm-tags" "helm-tags.el" (22404 60264 245872
+;;;;;;  444000))
 ;;; Generated autoloads from helm-tags.el

 (autoload 'helm-etags-select "helm-tags" "\
@ -939,8 +933,8 @@ This function aggregates three sources of tag files:

 ;;;***

-;;;### (autoloads nil "helm-utils" "helm-utils.el" (22387 29367 72811
-;;;;;;  347000))
+;;;### (autoloads nil "helm-utils" "helm-utils.el" (22404 60264 221872
+;;;;;;  319000))
 ;;; Generated autoloads from helm-utils.el

 (defvar helm-popup-tip-mode nil "\
@ -960,8 +954,8 @@ Show help-echo informations in a popup tip at end of line.
 ;;;***

 ;;;### (autoloads nil nil ("helm-easymenu.el" "helm-multi-match.el"
-;;;;;;  "helm-pkg.el" "helm-plugin.el" "helm-types.el") (22387 29367
-;;;;;;  261328 856000))
+;;;;;;  "helm-pkg.el" "helm-plugin.el" "helm-types.el") (22404 60264
+;;;;;;  421892 158000))

 ;;;***

--- a/elpa/helm-20160711.1143/helm-bookmark.el
+++ b/elpa/helm-20160711.1143/helm-bookmark.el
@ -30,6 +30,7 @@
 (declare-function message-buffers "message.el")
 (declare-function addressbook-set-mail-buffer-1 "ext:addressbook-bookmark.el"
                  (&optional bookmark-name append cc))
+(declare-function helm-browse-project "helm-files" (arg))


 (defgroup helm-bookmark nil
@ -456,8 +457,42 @@ than `w3m-browse-url' use it."
  "Specialized filter function for `helm-find-files' bookmarks."
  (helm-bookmark-filter-setup-alist 'helm-bookmark-helm-find-files-p))

+(defun helm-bookmark-browse-project (candidate)
+  "Run `helm-browse-project' from action."
+  (with-helm-default-directory
+      (bookmark-get-filename candidate)
+      (helm-browse-project nil)))
+
+(defun helm-bookmark-run-browse-project ()
+  "Run `helm-bookmark-browse-project' from keyboard."
+  (interactive)
+  (with-helm-alive-p
+    (helm-exit-and-execute-action 'helm-bookmark-browse-project)))
+(put 'helm-bookmark-run-browse-project 'helm-only t)
+
+(defvar helm-bookmark-find-files-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map helm-bookmark-map)
+    (define-key map (kbd "C-c o")   'ignore)
+    (define-key map (kbd "C-x C-d") 'helm-bookmark-run-browse-project)
+    map))
+
+(defclass helm-bookmark-overwrite-inheritor (helm-source) ())
+
+(defmethod helm--setup-source ((source helm-bookmark-overwrite-inheritor))
+  (setf (slot-value source 'action)
+        (helm-append-at-nth
+         (remove '("Jump to BM other window" . helm-bookmark-jump-other-window)
+                 helm-type-bookmark-actions)
+         '(("Browse project" . helm-bookmark-browse-project)) 1))
+  (setf (slot-value source 'keymap) helm-bookmark-find-files-map))
+
+(defclass helm-bookmark-find-files-class (helm-source-filtered-bookmarks
+                                          helm-bookmark-overwrite-inheritor)
+  ())
+
 (defvar helm-source-bookmark-helm-find-files
-  (helm-make-source "Bookmark helm-find-files sessions" 'helm-source-filtered-bookmarks
+  (helm-make-source "Bookmark helm-find-files sessions" 'helm-bookmark-find-files-class
      :init (lambda ()
              (bookmark-maybe-load-default-file)
              (helm-init-candidates-in-buffer
@ -683,7 +718,7 @@ words from the buffer into the new bookmark name."
  "Jump to bookmark from keyboard."
  (interactive)
  (with-helm-alive-p
-    (helm-exit-and-execute-action 'bookmark-jump-other-window)))
+    (helm-exit-and-execute-action 'helm-bookmark-jump-other-window)))
 (put 'helm-bookmark-run-jump-other-window 'helm-only t)

 (defun helm-bookmark-run-delete ()
--- a/elpa/helm-20160711.1143/helm-buffers.el
+++ b/elpa/helm-20160711.1143/helm-buffers.el
@ -423,7 +423,7 @@ Should be called after others transformers i.e (boring buffers)."
    (let ((preselect (helm-buffer--get-preselection
                      (helm-get-selection))))
      (setq helm-buffer-details-flag (not helm-buffer-details-flag))
-      (helm-force-update preselect))))
+      (helm-update preselect))))
 (put 'helm-toggle-buffers-details 'helm-only t)

 (defun helm-buffers-sort-transformer (candidates _source)
--- a/elpa/helm-20160711.1143/helm-color.el
+++ b/elpa/helm-20160711.1143/helm-color.el
--- a/elpa/helm-20160711.1143/helm-command.el
+++ b/elpa/helm-20160711.1143/helm-command.el
--- a/elpa/helm-20160711.1143/helm-config.el
+++ b/elpa/helm-20160711.1143/helm-config.el
@ -146,7 +146,6 @@
     ("(\\<\\(with-helm-default-directory\\)\\>" 1 font-lock-keyword-face)
     ("(\\<\\(with-helm-display-same-window\\)\\>" 1 font-lock-keyword-face)
     ("(\\<\\(with-helm-restore-variables\\)\\>" 1 font-lock-keyword-face)
-     ("(\\<\\(define-helm-type-attribute\\)\\>" 1 font-lock-keyword-face)
     ("(\\<\\(helm-multi-key-defun\\)\\>" 1 font-lock-keyword-face)
     ("(\\<\\(helm-while-no-input\\)\\>" 1 font-lock-keyword-face)
     ("(\\<\\(helm-aif\\)\\>" 1 font-lock-keyword-face)
--- a/elpa/helm-20160711.1143/helm-dabbrev.el
+++ b/elpa/helm-20160711.1143/helm-dabbrev.el
--- a/elpa/helm-20160711.1143/helm-easymenu.el
+++ b/elpa/helm-20160711.1143/helm-easymenu.el
--- a/elpa/helm-20160711.1143/helm-elisp-package.el
+++ b/elpa/helm-20160711.1143/helm-elisp-package.el
--- a/elpa/helm-20160711.1143/helm-elisp.el
+++ b/elpa/helm-20160711.1143/helm-elisp.el
@ -89,8 +89,7 @@ fuzzy completion is not available in `completion-at-point'."
                                        helm-def-source--eieio-classes
                                        helm-def-source--eieio-generic
                                        helm-def-source--emacs-variables
-                                        helm-def-source--emacs-faces
-                                        helm-def-source--helm-attributes)
+                                        helm-def-source--emacs-faces)
  "A list of functions that build helm sources to use in `helm-apropos'."
  :group 'helm-elisp
  :type '(repeat (choice symbol)))
@ -550,24 +549,6 @@ Filename completion happen if string start after or between a double quote."
              ("Customize face" . (lambda (candidate)
                                    (customize-face (helm-symbolify candidate)))))))

-(defun helm-def-source--helm-attributes (&optional _default)
-  (let ((def-act (lambda (candidate)
-                   (let (special-display-buffer-names
-                         special-display-regexps
-                         helm-persistent-action-use-special-display)
-                     (with-output-to-temp-buffer "*Help*"
-                       (princ (get (intern candidate) 'helm-attrdoc)))))))
-    (helm-build-sync-source "Helm attributes"
-      :candidates (lambda ()
-                    (mapcar 'symbol-name helm-attributes))
-      :fuzzy-match helm-apropos-fuzzy-match
-      :nomark t
-      :persistent-action (lambda (candidate)
-                           (helm-elisp--persistent-help
-                            candidate def-act))
-      :persistent-help "Describe helm attribute"
-      :action def-act)))
-
 (defun helm-def-source--emacs-commands (&optional default)
  (helm-build-in-buffer-source "Commands"
    :init `(lambda ()
--- a/elpa/helm-20160711.1143/helm-elscreen.el
+++ b/elpa/helm-20160711.1143/helm-elscreen.el
--- a/elpa/helm-20160711.1143/helm-eshell.el
+++ b/elpa/helm-20160711.1143/helm-eshell.el
--- a/elpa/helm-20160711.1143/helm-eval.el
+++ b/elpa/helm-20160711.1143/helm-eval.el
--- a/elpa/helm-20160711.1143/helm-external.el
+++ b/elpa/helm-20160711.1143/helm-external.el
--- a/elpa/helm-20160711.1143/helm-files.el
+++ b/elpa/helm-20160711.1143/helm-files.el
--- a/elpa/helm-20160711.1143/helm-font.el
+++ b/elpa/helm-20160711.1143/helm-font.el
--- a/elpa/helm-20160711.1143/helm-grep.el
+++ b/elpa/helm-20160711.1143/helm-grep.el
--- a/elpa/helm-20160711.1143/helm-help.el
+++ b/elpa/helm-20160711.1143/helm-help.el
@ -1111,414 +1111,6 @@ f1/f2/f-n:NthAct \
 f1/f2/f-n:NthAct \
 \\[helm-toggle-suspend-update]:Tog.suspend")

-
-;;; Attribute Documentation
-;;
-;;
-;;;###autoload
-(defun helm-describe-helm-attribute (helm-attribute)
-  "Display the full documentation of HELM-ATTRIBUTE.
-HELM-ATTRIBUTE should be a symbol."
-  (interactive (list (intern
-                      (completing-read
-                       "Describe helm attribute: "
-                       (mapcar 'symbol-name helm-attributes)
-                       nil t))))
-  (with-output-to-temp-buffer "*Help*"
-    (princ (get helm-attribute 'helm-attrdoc))))
-
-(helm-document-attribute 'name "mandatory"
-  "  The name of the source. It is also the heading which appears
-  above the list of matches from the source. Must be unique.")
-
-(helm-document-attribute 'header-name "optional"
-  "  A function returning the display string of the header. Its
-  argument is the name of the source. This attribute is useful to
-  add an additional information with the source name.")
-
-(helm-document-attribute 'candidates "mandatory if candidates-in-buffer attribute is not provided"
-  "  Specifies how to retrieve candidates from the source. It can
-  either be a variable name, a function called with no parameters
-  or the actual list of candidates.
-
-  The list must be a list whose members are strings, symbols
-  or (DISPLAY . REAL) pairs.
-
-  In case of (DISPLAY . REAL) pairs, the DISPLAY string is shown
-  in the Helm buffer, but the REAL one is used as action
-  argument when the candidate is selected. This allows a more
-  readable presentation for candidates which would otherwise be,
-  for example, too long or have a common part shared with other
-  candidates which can be safely replaced with an abbreviated
-  string for display purposes.
-
-  Note that if the (DISPLAY . REAL) form is used then pattern
-  matching is done on the displayed string, not on the real
-  value.
-
-  If the candidates have to be retrieved asynchronously (for
-  example, by an external command which takes a while to run)
-  then the function should start the external command
-  asynchronously and return the associated process object.
-  Helm will take care of managing the process (receiving the
-  output from it, killing it if necessary, etc.). The process
-  should return candidates matching the current pattern (see
-  variable `helm-pattern'.)
-  You should use instead `candidates-process' attribute for
-  async processes, a warning will popup when using async process
-  in a `candidates' attribute.
-
-  Note that currently results from asynchronous sources appear
-  last in the helm buffer regardless of their position in
-  `helm-sources'.")
-
-(helm-document-attribute 'candidates-process
-    "Same as `candidates' attributes but for process function."
-  "  You should use this attribute when using a function involving
-  an async process instead of `candidates'.")
-
-(helm-document-attribute 'action "mandatory if type attribute is not provided"
-  "  It is a list of (DISPLAY . FUNCTION) pairs or FUNCTION.
-  FUNCTION is called with one parameter: the selected candidate.
-
-  An action other than the default can be chosen from this list
-  of actions for the currently selected candidate (by default
-  with TAB). The DISPLAY string is shown in the completions
-  buffer and the FUNCTION is invoked when an action is
-  selected. The first action of the list is the default.")
-
-(helm-document-attribute 'coerce "optional"
-  "  It's a function called with one argument: the selected
-  candidate.
-
-  This function is intended for type convertion. In normal case,
-  the selected candidate (string) is passed to action
-  function. If coerce function is specified, it is called just
-  before action function.
-
-  Example: converting string to symbol
-    (coerce . intern)")
-
-(helm-document-attribute 'type "optional if action attribute is provided"
-  "  Indicates the type of the items the source returns.
-
-  Merge attributes not specified in the source itself from
-  `helm-type-attributes'.
-
-  This attribute is implemented by plug-in.")
-
-(helm-document-attribute 'init "optional"
-  "  Function called with no parameters when helm is started. It
-  is useful for collecting current state information which can be
-  used to create the list of candidates later.
-
-  For example, if a source needs to work with the current
-  directory then it can store its value here, because later
-  helm does its job in the minibuffer and in the
-  `helm-buffer' and the current directory can be different
-  there.")
-
-(helm-document-attribute 'match "optional"
-  "  List of functions called with one parameter: a candidate. The
-  function should return non-nil if the candidate matches the
-  current pattern (see variable `helm-pattern').
-
-  This attribute allows the source to override the default
-  pattern matching based on `string-match'. It can be used, for
-  example, to implement a source for file names and do the
-  pattern matching on the basename of files, since it's more
-  likely one is typing part of the basename when searching for a
-  file, instead of some string anywhere else in its path.
-
-  If the list contains more than one function then the list of
-  matching candidates from the source is constructed by appending
-  the results after invoking the first function on all the
-  potential candidates, then the next function, and so on. The
-  matching candidates supplied by the first function appear first
-  in the list of results and then results from the other
-  functions, respectively.
-
-  This attribute has no effect for asynchronous sources (see
-  attribute `candidates'), since they perform pattern matching
-  themselves.")
-
-(helm-document-attribute 'candidate-transformer "optional"
-  "  It's a function or a list of functions called with one argument
-  when the completion list from the source is built. The argument
-  is the list of candidates retrieved from the source. The
-  function should return a transformed list of candidates which
-  will be used for the actual completion.  If it is a list of
-  functions, it calls each function sequentially.
-
-  This can be used to transform or remove items from the list of
-  candidates.
-
-  Note that `candidates' is run already, so the given transformer
-  function should also be able to handle candidates with (DISPLAY
-  . REAL) format.")
-
-(helm-document-attribute 'filtered-candidate-transformer "optional"
-  "  It has the same format as `candidate-transformer', except the
-  function is called with two parameters: the candidate list and
-  the source.
-
-  This transformer is run on the candidate list which is already
-  filtered by the current pattern. While `candidate-transformer'
-  is run only once, it is run every time the input pattern is
-  changed.
-
-  It can be used to transform the candidate list dynamically, for
-  example, based on the current pattern.
-
-  In some cases it may also be more efficent to perform candidate
-  transformation here, instead of with `candidate-transformer'
-  even if this transformation is done every time the pattern is
-  changed.  For example, if a candidate set is very large then
-  `candidate-transformer' transforms every candidate while only
-  some of them will actually be dislpayed due to the limit
-  imposed by `helm-candidate-number-limit'.
-
-  Note that `candidates' and `candidate-transformer' is run
-  already, so the given transformer function should also be able
-  to handle candidates with (DISPLAY . REAL) format.
-
-  This option has no effect for asynchronous sources. (Not yet,
-  at least.")
-
-(helm-document-attribute 'action-transformer "optional"
-  "  It's a function or a list of functions called with two
-  arguments when the action list from the source is
-  assembled. The first argument is the list of actions, the
-  second is the current selection.  If it is a list of functions,
-  it calls each function sequentially.
-
-  The function should return a transformed action list.
-
-  This can be used to customize the list of actions based on the
-  currently selected candidate.")
-
-(helm-document-attribute 'pattern-transformer "optional"
-  "  It's a function or a list of functions called with one argument
-  before computing matches. Its argument is `helm-pattern'.
-  Functions should return transformed `helm-pattern'.
-
-  It is useful to change interpretation of `helm-pattern'.")
-
-(helm-document-attribute 'volatile "optional"
-  "  Indicates the source assembles the candidate list dynamically,
-  so it shouldn't be cached within a single Helm
-  invocation. It is only applicable to synchronous sources,
-  because asynchronous sources are not cached.")
-
-(helm-document-attribute 'requires-pattern "optional"
-  "  If present matches from the source are shown only if the
-  pattern is not empty. Optionally, it can have an integer
-  parameter specifying the required length of input which is
-  useful in case of sources with lots of candidates.")
-
-(helm-document-attribute 'persistent-action "optional"
-  "  Can be a either a Function called with one parameter (the
-  selected candidate) or a cons cell where first element is this
-  same function and second element a symbol (e.g. never-split)
-  that inform `helm-execute-persistent-action'to not split his
-  window to execute this persistent action.")
-
-(helm-document-attribute 'candidates-in-buffer "optional"
-  "  Shortcut attribute for making and narrowing candidates using
-  buffers.  This newly-introduced attribute prevents us from
-  forgetting to add volatile and match attributes.
-
-  See docstring of `helm-candidates-in-buffer'.
-
-  (candidates-in-buffer) is equivalent of three attributes:
-    (candidates . helm-candidates-in-buffer)
-    (volatile)
-    (match identity)
-
-  (candidates-in-buffer . candidates-function) is equivalent of:
-    (candidates . candidates-function)
-    (volatile)
-    (match identity)
-
-  This attribute is implemented by plug-in.")
-
-(helm-document-attribute 'search "optional"
-  "  List of functions like `re-search-forward' or `search-forward'.
-  Buffer search function used by `helm-candidates-in-buffer'.
-  By default, `helm-candidates-in-buffer' uses
-  `re-search-forward'. This attribute is meant to be used with
-  (candidates . helm-candidates-in-buffer) or
-  (candidates-in-buffer) in short.")
-
-(helm-document-attribute 'get-line "optional"
-  "  A function like `buffer-substring-no-properties' or `buffer-substring'.
-  This function converts point of line-beginning and point of line-end,
-  which represents a candidate computed by `helm-candidates-in-buffer'.
-  By default, `helm-candidates-in-buffer' uses
-  `buffer-substring-no-properties'.")
-
-(helm-document-attribute 'display-to-real "optional"
-  "  Function called with one parameter; the selected candidate.
-
-  The function transforms the selected candidate, and the result
-  is passed to the action function.  The display-to-real
-  attribute provides another way to pass other string than one
-  shown in Helm buffer.
-
-  Traditionally, it is possible to make candidates,
-  candidate-transformer or filtered-candidate-transformer
-  function return a list with (DISPLAY . REAL) pairs. But if REAL
-  can be generated from DISPLAY, display-to-real is more
-  convenient and faster.")
-
-(helm-document-attribute 'real-to-display "optional"
-  "  Function called with one parameter; the selected candidate.
-
-  The inverse of display-to-real attribute.
-
-  The function transforms the selected candidate, which is passed
-  to the action function, for display.  The real-to-display
-  attribute provides the other way to pass other string than one
-  shown in Helm buffer.
-
-  Traditionally, it is possible to make candidates,
-  candidate-transformer or filtered-candidate-transformer
-  function return a list with (DISPLAY . REAL) pairs. But if
-  DISPLAY can be generated from REAL, real-to-display is more
-  convenient.
-
-  Note that DISPLAY parts returned from candidates /
-  candidate-transformer are IGNORED as the name `display-to-real'
-  says.")
-
-(helm-document-attribute 'cleanup "optional"
-  "  Function called with no parameters when *helm* buffer is
-  closed. It is useful for killing unneeded candidates buffer.
-
-  Note that the function is executed BEFORE performing action.")
-
-(helm-document-attribute 'candidate-number-limit "optional"
-  "  Override `helm-candidate-number-limit' only for this source.")
-
-(helm-document-attribute 'accept-empty "optional"
-  "  Pass empty string \"\" to action function.")
-
-(helm-document-attribute 'dummy "optional"
-  "  Set `helm-pattern' to candidate. If this attribute is
-  specified, The candidates attribute is ignored.
-
-  This attribute is implemented by plug-in.")
-
-(helm-document-attribute 'multiline "optional"
-  "  Enable to selection multiline candidates.")
-
-(helm-document-attribute 'update "optional"
-  (substitute-command-keys
-   "  Function called with no parameters at before \"init\" function when \
-\\<helm-map>\\[helm-force-update] is pressed."))
-
-(helm-document-attribute 'mode-line "optional"
-  "  Source local `helm-mode-line-string' (included in
-  `mode-line-format'). It accepts also variable/function name.")
-
-(helm-document-attribute 'header-line "optional"
-  "  Source local `header-line-format'.
-  It accepts also variable/function name. ")
-
-(helm-document-attribute
-    'resume "optional"
-  "  Function called with no parameters at end of initialization
-  when `helm-resume' is started.
-  If this function try to do something against `helm-buffer', \(e.g. updating,
-  searching etc...\) probably you should run it in a timer to ensure
-  `helm-buffer' is ready.")
-
-(helm-document-attribute 'keymap "optional"
-  "  Specific keymap for this source.
-  It is useful to have a keymap per source when using more than
-  one source.  Otherwise, a keymap can be set per command with
-  `helm' argument KEYMAP.  NOTE: when a source have `helm-map' as
-  keymap attr, the global value of `helm-map' will override the
-  actual local one.")
-
-(helm-document-attribute 'help-message "optional"
-  "  Help message for this source.
-  If not present, `helm-help-message' value will be used.")
-
-(helm-document-attribute 'match-part "optional"
-  "  Allow matching candidate in the line with `candidates-in-buffer'.
-  In candidates-in-buffer sources, match is done with
-  `re-search-forward' which allow matching only a regexp on the
-  `helm-buffer'; when this search is done, match-part allow
-  matching only a specific part of the current line e.g. with a
-  line like this:
-
-  filename:candidate-containing-the-word-filename
-
-  What you want is to ignore \"filename\" part and match only
-  \"candidate-containing-the-word-filename\"
-
-  So give a function matching only the part of candidate after \":\"
-
-  If source contain match-part attribute, match is computed only
-  on part of candidate returned by the call of function provided
-  by this attribute. The function should have one arg, candidate,
-  and return only a specific part of candidate.
-
-  NOTE: This have effect only on sources using
-  `candidates-in-buffer'.")
-
-(helm-document-attribute 'match-strict "optional"
-  "  When specifying a match function within a source and
-  helm-multi-match is enabled, the result of all matching
-  functions will be concatened, which in some cases is not what
-  is wanted. When using `match-strict' only this or these
-  functions will be used. You can specify those functions as a
-  list of functions or a single symbol function. For anonymous
-  function don't add the dot, e.g:
-
-  \(match-strict (lambda () (foo))).")
-
-(helm-document-attribute 'nohighlight "optional"
-  "  Disable highlight match in this source.")
-
-(helm-document-attribute 'no-matchplugin "optional"
-  "  Disable matchplugin for this source.")
-
-(helm-document-attribute 'history "optional"
-  "  Allow passing history variable to helm from source.
-  It should be a quoted symbol evaluated from source, i.e:
-  (history . ,'history-var)")
-
-(helm-document-attribute 'follow "optional"
-  "  Enable `helm-follow-mode' for this source only.
-  You must give it a value of 1 or -1, though giving a -1 value
-  is surely not what you want, e.g: (follow . 1)
-
-  See `helm-follow-mode' for more infos")
-
-(helm-document-attribute 'follow-delay "optional"
-  "  `helm-follow-mode' will execute persistent-action after this delay.
-  Otherwise value of `helm-follow-input-idle-delay' is used if non--nil,
-  If none of these are found fallback to `helm-input-idle-delay'.")
-
-(helm-document-attribute 'allow-dups "optional"
-  "  Allow helm collecting duplicates candidates.")
-
-(helm-document-attribute 'filter-one-by-one "optional"
-  "  A transformer function that treat candidates one by one.
-  It is called with one arg the candidate.
-  It is faster than `filtered-candidate-transformer' or `candidates-transformer',
-  but should be used only in sources that recompute constantly their candidates,
-  e.g. `helm-source-find-files'.
-  Filtering happen early and candidates are treated
-  one by one instead of re-looping on the whole list.
-  If used with `filtered-candidate-transformer' or `candidates-transformer'
-  these functions should treat the candidates transformed by the `filter-one-by-one'
-  function in consequence.")
-
-(helm-document-attribute 'nomark "optional"
-  "  Don't allow marking candidates when this attribute is present.")

 (provide 'helm-help)

--- a/elpa/helm-20160711.1143/helm-id-utils.el
+++ b/elpa/helm-20160711.1143/helm-id-utils.el
--- a/elpa/helm-20160711.1143/helm-imenu.el
+++ b/elpa/helm-20160711.1143/helm-imenu.el
--- a/elpa/helm-20160711.1143/helm-info.el
+++ b/elpa/helm-20160711.1143/helm-info.el
--- a/elpa/helm-20160711.1143/helm-locate.el
+++ b/elpa/helm-20160711.1143/helm-locate.el
--- a/elpa/helm-20160711.1143/helm-man.el
+++ b/elpa/helm-20160711.1143/helm-man.el
--- a/elpa/helm-20160711.1143/helm-misc.el
+++ b/elpa/helm-20160711.1143/helm-misc.el
--- a/elpa/helm-20160711.1143/helm-mode.el
+++ b/elpa/helm-20160711.1143/helm-mode.el
@ -274,11 +274,17 @@ If COLLECTION is an `obarray', a TEST should be needed. See `obarray'."
        (helm-next-line))))

 (defun helm-cr-default (default cands)
-  (cond ((and (stringp default) (not (string= default "")))
-         (delq nil (cons default (delete default cands))))
-        ((consp default)
-         (append default cands))
-        (t cands)))
+  (delq nil
+        (cond ((and (stringp default) (not (string= default "")))
+               (cons default (delete default cands)))
+              ((consp default)
+               (append (cl-loop for d in default
+                                ;; Don't convert
+                                ;; nil to "nil" (i.e the string)
+                                ;; it will be delq'ed on top.
+                                collect (if (null d) d (helm-stringify d)))
+                       cands))
+              (t cands))))

 ;;;###autoload
 (cl-defun helm-comp-read (prompt collection
@ -460,9 +466,11 @@ that use `helm-comp-read' See `helm-M-x' for example."
                         (append '((lambda (candidates sources)
                                     (cl-loop for i in candidates
                                              ;; Input is added to history in completing-read's
-                                              ;; and may be regexp-quoted, so unquote it.
-                                              for cand = (replace-regexp-in-string "\\s\\" "" i)
-                                              collect cand)))
+                                              ;; and may be regexp-quoted, so unquote it
+                                              ;; but check if cand is a string (it may be at this stage
+                                              ;; a symbol or nil) Issue #1553.
+                                              when (stringp i)
+                                              collect (replace-regexp-in-string "\\s\\" "" i))))
                                 (and hist-fc-transformer (helm-mklist hist-fc-transformer)))
                         :persistent-action persistent-action
                         :persistent-help persistent-help
--- a/elpa/helm-20160711.1143/helm-multi-match.el
+++ b/elpa/helm-20160711.1143/helm-multi-match.el
--- a/elpa/helm-20160711.1143/helm-net.el
+++ b/elpa/helm-20160711.1143/helm-net.el
@ -413,12 +413,13 @@ and not be prompted to kill firefox process.
 NOTE: Probably not supported on some systems (e.g Windows)."
  (interactive (list (read-string "URL: " (browse-url-url-at-point))
                     nil))
+  (setq url (browse-url-encode-url url))
  (let ((process-environment (browse-url-process-environment)))
    (call-process-shell-command
     (format "(%s %s %s &)"
             browse-url-firefox-program
             helm-browse-url-firefox-new-window
-             url))))
+             (shell-quote-argument url)))))

 (defun helm-browse-url-chromium (url &optional _ignore)
  "Browse URL with google chrome browser."
--- a/elpa/helm-20160711.1143/helm-org.el
+++ b/elpa/helm-20160711.1143/helm-org.el
--- a/elpa/helm-20160711.1143/helm-pkg.el
+++ b/elpa/helm-20160711.1143/helm-pkg.el
@ -1,4 +1,4 @@
-(define-package "helm" "20160625.2316" "Helm is an Emacs incremental and narrowing framework"
+(define-package "helm" "20160711.1143" "Helm is an Emacs incremental and narrowing framework"
  '((emacs "24.3")
    (async "1.9")
    (popup "0.5.3")
--- a/elpa/helm-20160711.1143/helm-plugin.el
+++ b/elpa/helm-20160711.1143/helm-plugin.el
@ -42,13 +42,6 @@

 (add-to-list 'helm-compile-source-functions 'helm-compile-source--info-index)

-(helm-document-attribute 'info-index "info-index plugin"
-  "  Create a source of info index very easily.
-
-  Example:
-
-  (defvar helm-source-info-wget '((info-index . \"wget\"))")
-

 ;;; Plug-in: `candidates-file'
 ;;
@ -76,21 +69,6 @@
        (font-lock-mode -1)
        (auto-revert-mode 1)))))

-(helm-document-attribute 'candidates-file "candidates-file plugin"
-  "  Use a file as the candidates buffer.
-
-  1st argument is a filename, string or function name or variable
-  name. If optional 2nd argument is non-nil, the file is opened with
-  `auto-revert-mode' enabled.
-
-  Example:
-
-  \(defvar helm-source-test-file
-    '((name . \"test1\")
-      (candidates-file \"~/.emacs.el\" t)))
-
-  Will list all lines in .emacs.el.")
-

 ;;; Plug-in: `persistent-help'
 ;;
@ -117,13 +95,6 @@
               "")
           " (keeping session)")))

-
-;;; Document new attributes
-;;
-;;
-(helm-document-attribute 'persistent-help "persistent-help plug-in"
-  "  A string to explain persistent-action of this source. It also
-  accepts a function or a variable name.")


 (provide 'helm-plugin)
--- a/elpa/helm-20160711.1143/helm-regexp.el
+++ b/elpa/helm-20160711.1143/helm-regexp.el
--- a/elpa/helm-20160711.1143/helm-ring.el
+++ b/elpa/helm-20160711.1143/helm-ring.el
--- a/elpa/helm-20160711.1143/helm-semantic.el
+++ b/elpa/helm-20160711.1143/helm-semantic.el
--- a/elpa/helm-20160711.1143/helm-sys.el
+++ b/elpa/helm-20160711.1143/helm-sys.el
--- a/elpa/helm-20160711.1143/helm-tags.el
+++ b/elpa/helm-20160711.1143/helm-tags.el
@ -204,8 +204,9 @@ If no entry in cache, create one."
                ;; If an entry exists modify it.
                (setcdr it (helm-etags-mtime f))
              ;; No entry create a new one.
-              (add-to-list 'helm-etags-mtime-alist
-                           (cons f (helm-etags-mtime f))))))))))
+              (cl-pushnew (cons f (helm-etags-mtime f))
+                          helm-etags-mtime-alist
+                          :test 'equal))))))))

 (defvar helm-source-etags-select nil
  "Helm source for Etags.")
--- a/elpa/helm-20160711.1143/helm-types.el
+++ b/elpa/helm-20160711.1143/helm-types.el
--- a/elpa/helm-20160711.1143/helm-utils.el
+++ b/elpa/helm-20160711.1143/helm-utils.el
@ -384,8 +384,8 @@ from its directory."
                           (string-match ffap-url-regexp it))
                      it (expand-file-name it))
                default-directory))
-         ((or (file-remote-p sel)
-              (file-exists-p sel))
+         ((and (stringp sel) (or (file-remote-p sel)
+                                 (file-exists-p sel)))
          (expand-file-name sel))
         ;; Grep.
         ((and grep-line (file-exists-p (car grep-line)))
@ -395,7 +395,7 @@ from its directory."
          (with-current-buffer (get-buffer (car grep-line))
            (or (buffer-file-name) default-directory)))
         ;; Url.
-         ((and ffap-url-regexp (string-match ffap-url-regexp sel)) sel)
+         ((and (stringp sel) ffap-url-regexp (string-match ffap-url-regexp sel)) sel)
         ;; Default.
         (t default-preselection))))))
 (put 'helm-quit-and-find-file 'helm-only t)
--- a/elpa/helm-ag-20160622.2235/helm-ag-pkg.el
+++ b/elpa/helm-ag-20160622.2235/helm-ag-pkg.el
@ -1 +0,0 @@
-(define-package "helm-ag" "20160622.2235" "the silver searcher with helm interface" '((emacs "24.3") (helm "1.7.7")) :url "https://github.com/syohex/emacs-helm-ag")
--- a/elpa/helm-ag-20160622.2235/helm-ag-autoloads.el
+++ b/elpa/helm-ag-20160622.2235/helm-ag-autoloads.el
@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "helm-ag" "helm-ag.el" (22387 29365 905711
-;;;;;;  0))
+;;;### (autoloads nil "helm-ag" "helm-ag.el" (22404 60254 733822
+;;;;;;  732000))
 ;;; Generated autoloads from helm-ag.el

 (autoload 'helm-ag-pop-stack "helm-ag" "\
@ -15,14 +15,6 @@
 (autoload 'helm-ag-clear-stack "helm-ag" "\


-\(fn)" t nil)
-
-(autoload 'helm-ag-mode "helm-ag" "\
-Major mode to provide actions in helm grep saved buffer.
-
-Special commands:
-\\{helm-ag-mode-map}
-
 \(fn)" t nil)

 (autoload 'helm-ag-this-file "helm-ag" "\
--- a/elpa/helm-ag-20160702.324/helm-ag-pkg.el
+++ b/elpa/helm-ag-20160702.324/helm-ag-pkg.el
@ -0,0 +1 @@
+(define-package "helm-ag" "20160702.324" "the silver searcher with helm interface" '((emacs "24.3") (helm "1.7.7")) :url "https://github.com/syohex/emacs-helm-ag")
--- a/elpa/helm-ag-20160622.2235/helm-ag.el
+++ b/elpa/helm-ag-20160622.2235/helm-ag.el
@ -4,7 +4,7 @@

 ;; Author: Syohei YOSHIDA <syohex@gmail.com>
 ;; URL: https://github.com/syohex/emacs-helm-ag
-;; Package-Version: 20160622.2235
+;; Package-Version: 20160702.324
 ;; Version: 0.56
 ;; Package-Requires: ((emacs "24.3") (helm "1.7.7"))

@ -430,7 +430,6 @@ Default behaviour shows finish and result in mode-line."
    :fuzzy-match helm-ag-fuzzy-match
    :action helm-ag--actions
    :candidate-number-limit 9999
-    :keymap helm-ag-map
    :follow (and helm-follow-mode-persistent 1)))

 ;;;###autoload
@ -667,7 +666,6 @@ Default behaviour shows finish and result in mode-line."
    (define-key map (kbd "g") 'helm-ag--update-save-results)
    map))

-;;;###autoload
 (define-derived-mode helm-ag-mode special-mode "helm-ag"
  "Major mode to provide actions in helm grep saved buffer.

@ -768,7 +766,7 @@ Continue searching the parent directory? "))
                  (helm-ag--default-directory parent))
             (setq helm-ag--last-default-directory default-directory)
             (helm-attrset 'name (helm-ag--helm-header default-directory) helm-ag-source)
-             (helm :sources '(helm-ag-source) :buffer "*helm-ag*")))))
+             (helm :sources '(helm-ag-source) :buffer "*helm-ag*" :keymap helm-ag-map)))))
    (message nil)))

 ;;;###autoload
@ -782,7 +780,7 @@ Continue searching the parent directory? "))
    (helm-attrset 'search-this-file (file-relative-name (buffer-file-name))
                  helm-ag-source)
    (helm-attrset 'name (format "Search at %s" filename) helm-ag-source)
-    (helm :sources '(helm-ag-source) :buffer "*helm-ag*")))
+    (helm :sources '(helm-ag-source) :buffer "*helm-ag*" :keymap helm-ag-map)))

 ;;;###autoload
 (defun helm-ag (&optional basedir)
@ -798,7 +796,7 @@ Continue searching the parent directory? "))
      (helm-ag--query)
      (helm-attrset 'search-this-file nil helm-ag-source)
      (helm-attrset 'name (helm-ag--helm-header helm-ag--default-directory) helm-ag-source)
-      (helm :sources '(helm-ag-source) :buffer "*helm-ag*"))))
+      (helm :sources '(helm-ag-source) :buffer "*helm-ag*" :keymap helm-ag-map))))

 (defun helm-ag--split-string (str)
  (with-temp-buffer
@ -997,8 +995,7 @@ Continue searching the parent directory? "))
    :nohighlight t
    :requires-pattern 3
    :candidate-number-limit 9999
-    :follow (and helm-follow-mode-persistent 1)
-    :keymap helm-do-ag-map))
+    :follow (and helm-follow-mode-persistent 1)))

 (defun helm-ag--do-ag-up-one-level ()
  (interactive)
@ -1015,7 +1012,7 @@ Continue searching the parent directory? "))
             (helm-attrset 'name (helm-ag--helm-header parent)
                           helm-source-do-ag)
             (helm :sources '(helm-source-do-ag) :buffer "*helm-ag*"
-                   :input initial-input)))))
+                   :keymap helm-do-ag-map :input initial-input)))))
    (message nil)))

 (defun helm-ag--set-do-ag-option ()
@ -1047,7 +1044,7 @@ Continue searching the parent directory? "))
                        helm-ag--default-directory))))
    (helm-attrset 'name (helm-ag--helm-header search-dir)
                  helm-source-do-ag)
-    (helm :sources '(helm-source-do-ag) :buffer "*helm-ag*"
+    (helm :sources '(helm-source-do-ag) :buffer "*helm-ag*" :keymap helm-do-ag-map
          :input (or (helm-ag--marked-input)
                     (helm-ag--insert-thing-at-point helm-ag-insert-at-point)))))

--- a/elpa/helm-core-20160711.1141/helm-core-autoloads.el
+++ b/elpa/helm-core-20160711.1141/helm-core-autoloads.el
@ -3,7 +3,7 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "helm" "helm.el" (22387 29365 581960 874000))
+;;;### (autoloads nil "helm" "helm.el" (22404 60254 377820 872000))
 ;;; 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") (22387 29365 611862 481000))
+;;;;;;  "helm-source.el") (22404 60254 406327 599000))

 ;;;***

--- a/elpa/helm-core-20160711.1141/helm-core-pkg.el
+++ b/elpa/helm-core-20160711.1141/helm-core-pkg.el
@ -1,4 +1,4 @@
-(define-package "helm-core" "20160627.324" "Development files for Helm"
+(define-package "helm-core" "20160711.1141" "Development files for Helm"
  '((emacs "24.3")
    (async "1.9"))
  :url "https://emacs-helm.github.io/helm/")
--- a/elpa/helm-core-20160711.1141/helm-lib.el
+++ b/elpa/helm-core-20160711.1141/helm-lib.el
--- a/elpa/helm-core-20160711.1141/helm-multi-match.el
+++ b/elpa/helm-core-20160711.1141/helm-multi-match.el
--- a/elpa/helm-core-20160711.1141/helm-source.el
+++ b/elpa/helm-core-20160711.1141/helm-source.el
@ -699,7 +699,7 @@ like `re-search-forward', see below documentation of :search slot.")
    :initform '("dummy"))

   (filtered-candidate-transformer
-    :initform 'helm-dummy-candidate)
+    :initform (lambda (_candidates _source) (list helm-pattern)))

   (matchplugin
    :initform nil)
--- a/elpa/helm-core-20160711.1141/helm.el
+++ b/elpa/helm-core-20160711.1141/helm.el
@ -662,16 +662,6 @@ See `helm-log-save-maybe' for more info."
 ;;; Variables.
 ;;
 ;;
-(defvar helm-type-attributes nil
-  "It's a list of \(TYPE ATTRIBUTES ...\).
-ATTRIBUTES are the same as attributes for `helm-sources'. TYPE
-connects the value to the appropriate sources. Don't set this
-directly, use `define-helm-type-attribute' instead.
-
-This alist is for specifying common attributes for multiple
-sources. For example, sources which provide files can specify
-common attributes with a `file' type.")
-
 (defvar helm-source-filter nil
  "A list of source names to be displayed.
 Other sources won't appear in the search results.
@ -776,10 +766,7 @@ If `nil', `helm-debug-output' includes only variables with
 Default is `nil', which disables writing log messages because the
 size of `helm-debug-buffer' grows quickly.")

-(defvar helm-compile-source-functions
-  '(helm-compile-source--type
-    helm-compile-source--dummy
-    helm-compile-source--candidates-in-buffer)
+(defvar helm-compile-source-functions nil 
  "Functions to compile elements of `helm-sources' (plug-in).")

 (defvar helm-mode-line-string "\
@ -960,7 +947,6 @@ in some special circumstances.
 See `helm-exit-minibuffer' and `helm-keyboard-quit'.")
 (defvar helm-minibuffer-confirm-state nil)
 (defvar helm-quit nil)
-(defvar helm-attributes nil "List of all `helm' attributes.")
 (defvar helm-buffers nil
  "Helm buffers listed in order of most recently used.")
 (defvar helm-current-position nil
@ -1053,7 +1039,7 @@ e.g (helm-log-error \"Error %s: %s\" (car err) (cdr err))."
  (apply 'helm-log (concat "ERROR: " (car args)) (cdr args))
  (let ((msg (apply 'format args)))
    (unless (member msg helm-issued-errors)
-      (add-to-list 'helm-issued-errors msg))))
+      (cl-pushnew msg helm-issued-errors :test 'equal))))

 (defun helm-log-save-maybe ()
  "Save log buffer if `helm-debug-root-directory' is set to a valid directory.
@ -1119,6 +1105,19 @@ and not `exit-minibuffer' or other unwanted functions."
                   (> (length btf) 2))
           return (cadr (cdr btf))))

+(defun helm-append-at-nth (seq elm index)
+  "Append ELM at INDEX in SEQ."
+  (let ((len (length seq)))
+    (cond ((> index len) (setq index len))
+          ((< index 0) (setq index 0)))
+    (if (zerop index)
+        (append elm seq)
+      (cl-loop for i in seq
+               for count from 1 collect i
+               when (= count index)
+               if (listp elm) append elm
+               else collect elm))))
+

 ;; Test tools
 (defmacro with-helm-time-after-update (&rest body)
@ -1187,17 +1186,18 @@ and not `exit-minibuffer' or other unwanted functions."
         (progn ,@body)
       (error "Running helm command outside of context"))))

+
+;;; helm-attributes
+;;
 (defun helm-attr (attribute-name &optional source compute)
  "Get the value of ATTRIBUTE-NAME of SRC.
 If SRC is omitted, use current source.
 If COMPUTE is non-`nil' compute value of ATTRIBUTE-NAME
 with `helm-interpret-value'.  COMPUTE can have also 'ignorefn as
 value, in this case `helm-interpret-value' will return a function
-as value unchanged, but will eval a symbol which is bound
-(i.e a variable)."
+as value unchanged, but will eval a symbol which is bound."
  (let ((src (or source (helm-get-current-source))))
-    (helm-aif (or (assq attribute-name src)
-                  (helm-get-attribute-from-source-type attribute-name src))
+    (helm-aif (assq attribute-name src)
        (if compute
            (helm-interpret-value (cdr it) src compute)
            (cdr it)))))
@ -1210,60 +1210,18 @@ if SRC is omitted, use current source."

 (cl-defun helm-attrset (attribute-name value
                                       &optional
-                                       (src (helm-get-current-source))
-                                       alter-type)
+                                       (src (helm-get-current-source)))
  "Set the value of ATTRIBUTE-NAME of source SRC to VALUE.
-If ATTRIBUTE-NAME doesn't exists in source it is created with value VALUE.
-If ALTER-TYPE is non-`nil' alter the value of ATTRIBUTE-NAME in `helm-attributes'
-if it exists.
+If ATTRIBUTE-NAME doesn't exists in source it is created with value VALUE..
 If SRC is omitted, use current source.
 If operation succeed, return value, otherwise nil."
-  (let ((from-type (helm-get-attribute-from-source-type attribute-name src))
-        done)
-    (helm-aif (or (assq attribute-name src)
-                  (and alter-type from-type))
+  (let (done)
+    (helm-aif (assq attribute-name src)
        (prog1 (setcdr it value) (setq done t))
-      (unless from-type
-        (setcdr src (cons (cons attribute-name value) (cdr src)))
-        (setq done t)))
+      (setcdr src (cons (cons attribute-name value) (cdr src)))
+      (setq done t))
    (and done value)))

-(defun helm-get-attribute-from-source-type (attribute source)
-  "Get ATTRIBUTE from type attribute of SOURCE."
-  (when (assq 'type source)
-    (assq attribute
-          (assq (cdr (assq 'type source))
-                helm-type-attributes))))
-
-(defun helm-get-attribute-from-type (attribute type)
-  "Get ATTRIBUTE from TYPE.
-arg TYPE is an existing type defined in `helm-type-attributes'."
-  (assq attribute (assq type helm-type-attributes)))
-
-(defun helm-get-actions-from-type (source)
-  "Get actions list from type attribute of SOURCE."
-  (when (assq 'type source)
-    (helm-get-attribute-from-source-type 'action source)))
-
-(defun helm-inherit-attribute-from-source (attribute source)
-  "Get the ATTRIBUTE of SOURCE."
-  (helm-aif (assq attribute source)
-      it
-    (helm-get-attribute-from-source-type attribute source)))
-
-(defun helm-append-at-nth (seq elm index)
-  "Append ELM at INDEX in SEQ."
-  (let ((len (length seq)))
-    (cond ((> index len) (setq index len))
-          ((< index 0) (setq index 0)))
-    (if (zerop index)
-        (append elm seq)
-      (cl-loop for i in seq
-               for count from 1 collect i
-               when (= count index)
-               if (listp elm) append elm
-               else collect elm))))
-
 (defun helm-add-action-to-source (name fn source &optional index)
  "Add new action NAME linked to function FN to SOURCE.
 Function FN should be a valid function that takes one arg i.e candidate,
@ -1336,6 +1294,9 @@ only when predicate helm-ff-candidates-lisp-p return non-`nil':
                     :test 'equal)
                    source))))

+
+;;; Source filter
+;;
 (defun helm-set-source-filter (sources)
  "Set the value of `helm-source-filter' to SOURCES and update.

@ -2226,7 +2187,8 @@ value of `helm-full-frame' or `helm-split-window-default-side'."
               (not helm-split-window-in-side-p))
      (delete-other-windows))
    (display-buffer
-     buffer `(nil . ((window-height . ,helm-display-buffer-default-size))))))
+     buffer `(nil . ((window-height . ,helm-display-buffer-default-size))))
+    (helm-log-run-hook 'helm-window-configuration-hook)))


 ;;; Core: initialize
@ -3358,7 +3320,7 @@ to a particular place after finishing update."
  (goto-char (point-min))
  (unless without-hook
    (save-excursion (helm-log-run-hook 'helm-update-hook)))
-  (helm-next-line))
+  (helm-move-selection-common :where 'line :direction 'next :follow nil))

 (defun helm-force-update (&optional preselect)
  "Force recalculation and update of candidates.
@ -3743,12 +3705,11 @@ DIRECTION is either 'next or 'previous."
                (" " mode-line-buffer-identification " "
                     (:eval (format "L%-3d" (helm-candidate-number-at-point)))
                     ,follow
+                     " "
                     (:eval ,(and marked
-                                  (concat
-                                   " "
-                                   (propertize
-                                    (format "M%d" (length marked))
-                                    'face 'helm-visible-mark))))
+                                  (propertize
+                                   (format "M%d" (length marked))
+                                   'face 'helm-visible-mark)))
                     (:eval (when ,helm--mode-line-display-prefarg
                              (let ((arg (prefix-numeric-value
                                          (or prefix-arg current-prefix-arg))))
@ -3849,7 +3810,7 @@ it is \"Candidate\(s\)\" by default."
                         cand-name))
         'face 'helm-candidate-number)))))

-(cl-defun helm-move-selection-common (&key where direction)
+(cl-defun helm-move-selection-common (&key where direction (follow t))
  "Move the selection marker to a new position.
 Position is determined by WHERE and DIRECTION.
 Key arg WHERE can be one of:
@ -3888,6 +3849,8 @@ Key arg DIRECTION can be one of:
        (helm-display-source-at-screen-top-maybe where)
        (when (helm-get-previous-header-pos)
          (helm-mark-current-line))
+        (when follow
+          (helm-follow-execute-persistent-action-maybe))
        (helm-display-mode-line (helm-get-current-source))
        (helm-log-run-hook 'helm-move-selection-after-hook)))))

@ -4120,8 +4083,7 @@ candidates."
               header-pos
               (point-max)))
       (1+ (point-at-eol))))
-    (setq helm-selection-point (overlay-start helm-selection-overlay)))
-  (helm-follow-execute-persistent-action-maybe))
+    (setq helm-selection-point (overlay-start helm-selection-overlay))))

 (defun helm-confirm-and-exit-minibuffer ()
  "Maybe ask for confirmation when exiting helm.
@ -4438,103 +4400,8 @@ When at the end of minibuffer, deletes all."
    (helm--delete-minibuffer-contents-from str)))


-;;; Plugins (Deprecated in favor of helm-types)
+;;; helm-source-in-buffer.
 ;;
-;; i.e Inherit instead of helm-type-* classes in your own classes.
-
-;; [DEPRECATED] Enable multi-match by default in old sources.
-;; This is deprecated and will not run in sources
-;; created by helm-source.
-;; Keep it for backward compatibility with old sources.
-(defun helm-compile-source--multi-match (source)
-  (if (assoc 'no-matchplugin source)
-      source
-    (let* ((searchers        helm-mm-default-search-functions)
-           (defmatch         (helm-aif (assoc-default 'match source)
-                                 (helm-mklist it)))
-           (defmatch-strict  (helm-aif (assoc-default 'match-strict source)
-                                 (helm-mklist it)))
-           (defsearch        (helm-aif (assoc-default 'search source)
-                                 (helm-mklist it)))
-           (defsearch-strict (helm-aif (assoc-default 'search-strict source)
-                                 (helm-mklist it)))
-           (matchfns         (cond (defmatch-strict)
-                                   (defmatch
-                                    (append helm-mm-default-match-functions defmatch))
-                                   (t helm-mm-default-match-functions)))
-           (searchfns        (cond (defsearch-strict)
-                                   (defsearch
-                                    (append searchers defsearch))
-                                   (t searchers))))
-      `(,(if (assoc 'candidates-in-buffer source)
-             `(search ,@searchfns) `(match ,@matchfns))
-         ,@source))))
-
-(add-to-list 'helm-compile-source-functions 'helm-compile-source--multi-match)
-
-(defun helm-compile-source--type (source)
-  (helm-aif (assoc-default 'type source)
-      (append source (assoc-default it helm-type-attributes) nil)
-    source))
-
-(defun define-helm-type-attribute (type definition &optional doc)
-  "Register type attribute of TYPE as DEFINITION with DOC.
-DOC is displayed in `helm-type-attributes' docstring.
-
-Using this function is better than setting `helm-type-attributes'
-directly."
-  (cl-loop for i in definition do
-       ;; without `ignore-errors', error at emacs22
-       (ignore-errors (setf i (delete nil i))))
-  (helm-add-type-attribute type definition)
-  (and doc (helm-document-type-attribute type doc))
-  nil)
-
-(defun helm-document-attribute (attribute short-doc &optional long-doc)
-  "Register ATTRIBUTE documentation introduced by plug-in.
-SHORT-DOC is displayed beside attribute name.
-LONG-DOC is displayed below attribute name and short documentation."
-  (declare (indent 2))
-  (if long-doc
-      (setq short-doc (concat "(" short-doc ")"))
-    (setq long-doc short-doc
-          short-doc ""))
-  (add-to-list 'helm-attributes attribute t)
-  (put attribute 'helm-attrdoc
-       (concat "- " (symbol-name attribute)
-               " " short-doc "\n\n" long-doc "\n")))
-
-(defun helm-add-type-attribute (type definition)
-  (helm-aif (assq type helm-type-attributes)
-      (setq helm-type-attributes (delete it helm-type-attributes)))
-  (push (cons type definition) helm-type-attributes))
-
-(defun helm-document-type-attribute (type doc)
-  (add-to-list 'helm-types type t)
-  (put type 'helm-typeattrdoc
-       (concat "- " (symbol-name type) "\n\n" doc "\n")))
-
-;; Built-in plug-in: dummy
-(defun helm-dummy-candidate (_candidate _source)
-  "Use `helm-pattern' as CANDIDATE in SOURCE."
-  ;; `source' is defined in filtered-candidate-transformer
-  (list helm-pattern))
-
-(defun helm-compile-source--dummy (source)
-  (if (assoc 'dummy source)
-      (progn
-        (unless (helm-attr-defined
-                 'filtered-candidate-transformer source)
-          (helm-attrset 'filtered-candidate-transformer
-                        'helm-dummy-candidate source))
-        (append source
-                '((candidates "dummy")
-                  (accept-empty)
-                  (match identity)
-                  (volatile))))
-    source))
-
-;; Built-in plug-in: candidates-in-buffer
 (defun helm-candidates-in-buffer (&optional source)
  "The top level function used to store candidates in `helm-source-in-buffer'.

@ -4832,15 +4699,6 @@ Returns the resulting buffer."
        (and (stringp data) (insert data))))
    buf))

-(defun helm-compile-source--candidates-in-buffer (source)
-  (helm-aif (assoc 'candidates-in-buffer source)
-      (append source
-              `((candidates . ,(or (cdr it)
-                                   (lambda ()
-                                     (helm-candidates-in-buffer source))))
-                (volatile) (match identity)))
-    source))
-

 ;;; Resplit helm window
 ;;
@ -5159,9 +5017,9 @@ Argument ACTION, when present, is used as second argument of `display-buffer'."
    (set (make-local-variable 'helm-visible-mark-overlays) nil)))

 (defun helm-this-visible-mark ()
-  (cl-loop for o in helm-visible-mark-overlays
-        when (equal (point-at-bol) (overlay-start o))
-        return o))
+  (cl-loop for o in (overlays-at (point))
+           when (overlay-get o 'visible-mark)
+           return o))

 (defun helm-delete-visible-mark (overlay)
  (setq helm-marked-candidates
@ -5172,7 +5030,7 @@ Argument ACTION, when present, is used as second argument of `display-buffer'."
  (setq helm-visible-mark-overlays
        (delq overlay helm-visible-mark-overlays)))

-(defun helm-make-visible-mark ()
+(defun helm-make-visible-mark (&optional src selection)
  (let ((o (make-overlay (point-at-bol)
                          (if (helm-pos-multiline-p)
                              (or (helm-get-next-candidate-separator-pos)
@ -5180,11 +5038,13 @@ Argument ACTION, when present, is used as second argument of `display-buffer'."
                            (1+ (point-at-eol))))))
    (overlay-put o 'priority 0)
    (overlay-put o 'face   'helm-visible-mark)
-    (overlay-put o 'source (assoc-default 'name (helm-get-current-source)))
+    (overlay-put o 'source (assoc-default 'name (or src (helm-get-current-source))))
    (overlay-put o 'string (buffer-substring (overlay-start o) (overlay-end o)))
-    (overlay-put o 'real   (helm-get-selection))
-    (add-to-list 'helm-visible-mark-overlays o))
-  (push (cons (helm-get-current-source) (helm-get-selection))
+    (overlay-put o 'real   (or selection (helm-get-selection)))
+    (overlay-put o 'visible-mark t)
+    (cl-pushnew o helm-visible-mark-overlays))
+  (push (cons (or src  (helm-get-current-source))
+              (or selection (helm-get-selection)))
        helm-marked-candidates))

 (defun helm-toggle-visible-mark ()
@ -5215,56 +5075,54 @@ Argument ACTION, when present, is used as second argument of `display-buffer'."
  (interactive)
  (with-helm-alive-p
    (with-helm-window
-      (let ((nomark (assq 'nomark (helm-get-current-source)))
-            (follow (if helm-follow-mode 1 -1)))
-        (helm-follow-mode -1)
-        (unwind-protect
-             (if nomark
-                 (message "Marking not allowed in this source")
-                 (save-excursion
-                   (goto-char (helm-get-previous-header-pos))
-                   (helm-next-line)
-                   (let* ((next-head (helm-get-next-header-pos))
-                          (end       (and next-head
-                                          (save-excursion
-                                            (goto-char next-head)
-                                            (forward-line -1)
-                                            (point))))
-                          (maxpoint  (or end (point-max))))
-                     (while (< (point) maxpoint)
-                       (helm-mark-current-line)
-                       (let* ((prefix (get-text-property (point-at-bol) 'display))
-                              (cand   (helm-get-selection))
-                              (bn     (and (helm-file-completion-source-p)
-                                           (helm-basename cand)))
-                              (src-name    (assoc-default 'name
-                                                          (helm-get-current-source))))
-                         (when (and (not (helm-this-visible-mark))
-                                    (not (or (string= prefix "[?]")
-                                             (string= prefix "[@]"))))
+      (let* ((follow     (if helm-follow-mode 1 -1))
+             (src        (helm-get-current-source))
+             (nomark     (assq 'nomark src))
+             (src-name   (assoc-default 'name src))
+             (filecomp-p (or (helm-file-completion-source-p)
+                             (string= src-name "Files from Current Directory")))
+             (remote-p (and filecomp-p (file-remote-p helm-pattern))))
+        (cl-letf (((symbol-function 'message) #'ignore))
+          (helm-follow-mode -1)
+          (unwind-protect
+               (if nomark
+                   (message "Marking not allowed in this source")
+                   (save-excursion
+                     (goto-char (helm-get-previous-header-pos))
+                     (forward-line 1)
+                     (let* ((next-head (helm-get-next-header-pos))
+                            (end       (and next-head
+                                            (save-excursion
+                                              (goto-char next-head)
+                                              (forward-line -1)
+                                              (point))))
+                            (maxpoint  (or end (point-max))))
+                       (while (< (point) maxpoint)
+                         (helm-mark-current-line)
+                         (let* ((prefix (get-text-property (point-at-bol) 'display))
+                                (cand   (helm-get-selection))
+                                (bn     (and filecomp-p (helm-basename cand))))
                           ;; Don't mark possibles directories ending with . or ..
                           ;; autosave files/links and non--existent file.
                           (unless
-                               (and (or (helm-file-completion-source-p)
-                                        (string=
-                                         src-name "Files from Current Directory"))
-                                    (or (string-match
-                                         "^[.]?#.*#?$\\|[^#]*[.]\\{1,2\\}$" bn)
-                                        ;; We need to test here when not using
-                                        ;; a transformer that tag prefix
-                                        ;; (i.e on tramp).
-                                        (not (file-exists-p cand))))
-                             (helm-make-visible-mark))))
-                       (if (helm-pos-multiline-p)
-                           (progn
-                             (goto-char
-                              (or (helm-get-next-candidate-separator-pos)
-                                  (point-max)))
-                             (forward-line 1))
-                           (forward-line 1))
-                       (end-of-line))))
-                 (helm-mark-current-line))
-          (helm-follow-mode follow) (message nil))))))
+                               (or (helm-this-visible-mark)
+                                   (string= prefix "[?]")   ; doesn't match
+                                   (and filecomp-p
+                                        (or (string-match-p ; autosave or dot files
+                                             "^[.]?#.*#?$\\|[^#]*[.]\\{1,2\\}$" bn)
+                                            ;; We need to test here when not using
+                                            ;; a transformer that put a prefix tag
+                                            ;; before candidate.
+                                            ;; (i.e no [?] prefix on tramp).
+                                            (and remote-p (not (file-exists-p cand))))))
+                             (helm-make-visible-mark src cand)))
+                         (when (helm-pos-multiline-p)
+                           (goto-char
+                            (or (helm-get-next-candidate-separator-pos)
+                                (point-max))))
+                         (forward-line 1))))
+                   (helm-mark-current-line))
+            (helm-follow-mode follow)))))))
 (put 'helm-mark-all 'helm-only t)

 (defun helm-unmark-all ()
@ -5292,7 +5150,7 @@ visible or invisible in all sources of current helm session"
          (helm-mark-all)))))
 (put 'helm-toggle-all-marks 'helm-only t)

-(defun helm--compute-marked (real source wildcard)
+(defun helm--compute-marked (real source &optional wildcard)
  (let* ((coerced (helm-coerce-selection real source))
         (wilds   (and wildcard
                       (condition-case nil
@ -5318,8 +5176,9 @@ selection. When key WITH-WILDCARD is specified, expand it."
    (let ((candidates
           (cl-loop with current-src = (helm-get-current-source)
                    for (source . real) in (reverse helm-marked-candidates)
+                    for use-wc = (and with-wildcard (string-match-p "\\*" real))
                    when (equal (assq 'name source) (assq 'name current-src))
-                    append (helm--compute-marked real source with-wildcard)
+                    append (helm--compute-marked real source use-wc)
                    into cands
                    finally return (or cands
                                       (append
--- a/elpa/js2-mode-20160626.2025/js2-imenu-extras.el
+++ b/elpa/js2-mode-20160626.2025/js2-imenu-extras.el
--- a/elpa/js2-mode-20160626.2025/js2-mode-autoloads.el
+++ b/elpa/js2-mode-20160626.2025/js2-mode-autoloads.el
@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (22387
-;;;;;;  29360 905580 641000))
+;;;### (autoloads nil "js2-imenu-extras" "js2-imenu-extras.el" (22404
+;;;;;;  60250 41798 228000))
 ;;; 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" (22387 29360 929562
-;;;;;;  12000))
+;;;### (autoloads nil "js2-mode" "js2-mode.el" (22404 60250 57798
+;;;;;;  312000))
 ;;; Generated autoloads from js2-mode.el

 (autoload 'js2-highlight-unused-variables-mode "js2-mode" "\
@ -49,14 +49,14 @@ variables (`sgml-basic-offset' et al) locally, like so:

  (defun set-jsx-indentation ()
    (setq-local sgml-basic-offset js2-basic-offset))
-  (add-hook 'js2-jsx-mode-hook #'set-jsx-indentation)
+  (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation)

 \(fn)" t nil)

 ;;;***

 ;;;### (autoloads nil nil ("js2-mode-pkg.el" "js2-old-indent.el")
-;;;;;;  (22387 29360 947929 521000))
+;;;;;;  (22404 60250 71483 180000))

 ;;;***

--- a/elpa/js2-mode-20160626.2025/js2-mode-pkg.el
+++ b/elpa/js2-mode-20160626.2025/js2-mode-pkg.el
@ -1,4 +1,4 @@
-(define-package "js2-mode" "20160626.2025" "Improved JavaScript editing mode"
+(define-package "js2-mode" "20160707.723" "Improved JavaScript editing mode"
  '((emacs "24.1")
    (cl-lib "0.5"))
  :url "https://github.com/mooz/js2-mode/" :keywords
--- a/elpa/js2-mode-20160626.2025/js2-mode.el
+++ b/elpa/js2-mode-20160626.2025/js2-mode.el
@ -6934,6 +6934,7 @@ of a simple name.  Called before EXPR has a parent node."
             "member"
             "memberOf"
             "method"
+             "module"
             "name"
             "namespace"
             "since"
@ -11619,7 +11620,7 @@ variables (`sgml-basic-offset' et al) locally, like so:

  (defun set-jsx-indentation ()
    (setq-local sgml-basic-offset js2-basic-offset))
-  (add-hook 'js2-jsx-mode-hook #'set-jsx-indentation)"
+  (add-hook \\='js2-jsx-mode-hook #\\='set-jsx-indentation)"
  (set (make-local-variable 'indent-line-function) #'js2-jsx-indent-line))

 (defun js2-mode-exit ()
--- a/elpa/js2-mode-20160626.2025/js2-old-indent.el
+++ b/elpa/js2-mode-20160626.2025/js2-old-indent.el
--- a/elpa/json-mode-20160601.356/json-mode-pkg.el
+++ b/elpa/json-mode-20160601.356/json-mode-pkg.el
@ -1 +0,0 @@
-(define-package "json-mode" "20160601.356" "Major mode for editing JSON files" '((json-reformat "0.0.5") (json-snatcher "1.0.0")) :url "https://github.com/joshwnj/json-mode")
--- a/elpa/json-mode-20160710.1637/json-mode-autoloads.el
+++ b/elpa/json-mode-20160710.1637/json-mode-autoloads.el
@ -3,8 +3,8 @@
 ;;; Code:
 (add-to-list 'load-path (or (file-name-directory #$) (car load-path)))

-;;;### (autoloads nil "json-mode" "json-mode.el" (22387 29360 294055
-;;;;;;  690000))
+;;;### (autoloads nil "json-mode" "json-mode.el" (22404 60234 333716
+;;;;;;  283000))
 ;;; Generated autoloads from json-mode.el

 (autoload 'json-mode "json-mode" "\
--- a/elpa/json-mode-20160710.1637/json-mode-pkg.el
+++ b/elpa/json-mode-20160710.1637/json-mode-pkg.el
@ -0,0 +1 @@
+(define-package "json-mode" "20160710.1637" "Major mode for editing JSON files" '((json-reformat "0.0.5") (json-snatcher "1.0.0")) :url "https://github.com/joshwnj/json-mode")
--- a/Show More
+++ b/Show More
				`@ -1 +0,0 @@`
				`(define-package "gitconfig-mode" "20160319.302" "Major mode for editing .gitconfig files" 'nil :url "https://github.com/magit/git-modes" :keywords '("convenience" "vc" "git"))`
				`@ -0,0 +1 @@`
				`(define-package "gitconfig-mode" "20160710.1913" "Major mode for editing .gitconfig files" 'nil :url "https://github.com/magit/git-modes" :keywords '("convenience" "vc" "git"))`
				`@ -1 +0,0 @@`
				`(define-package "helm-ag" "20160622.2235" "the silver searcher with helm interface" '((emacs "24.3") (helm "1.7.7")) :url "https://github.com/syohex/emacs-helm-ag")`
				`@ -0,0 +1 @@`
				`(define-package "helm-ag" "20160702.324" "the silver searcher with helm interface" '((emacs "24.3") (helm "1.7.7")) :url "https://github.com/syohex/emacs-helm-ag")`
				`@ -1 +0,0 @@`
				`(define-package "json-mode" "20160601.356" "Major mode for editing JSON files" '((json-reformat "0.0.5") (json-snatcher "1.0.0")) :url "https://github.com/joshwnj/json-mode")`
				`@ -0,0 +1 @@`
				`(define-package "json-mode" "20160710.1637" "Major mode for editing JSON files" '((json-reformat "0.0.5") (json-snatcher "1.0.0")) :url "https://github.com/joshwnj/json-mode")`