k now... emacs>vim

.emacs

@@ -0,0 +1,77 @@
+;; load emacs 24's package system. Add MELPA repository.
+
+;; Added by Package.el.  This must come before configurations of
+;; installed packages.  Don't delete this line.  If you don't want it,
+;; just comment it out by adding a semicolon to the start of the line.
+;; You may delete these explanatory comments.
+(package-initialize)
+
+(when (>= emacs-major-version 24)
+  (require 'package)
+  (add-to-list
+   'package-archives
+   ;; '("melpa" . "http://stable.melpa.org/packages/") ; many packages won't show if using stable
+   '("melpa" . "http://melpa.milkbox.net/packages/")
+   '("elpy" . "http://jorgenschaefer.github.io/packages/")
+   ))
+(custom-set-variables
+ ;; custom-set-variables was added by Custom.
+ ;; If you edit it by hand, you could mess it up, so be careful.
+ ;; Your init file should contain only one such instance.
+ ;; If there is more than one, they won't work right.
+ '(custom-safe-themes
+   (quote
+    ("66881e95c0eda61d34aa7f08ebacf03319d37fe202d68ecf6a1dbfd49d664bc3" default)))
+ '(inhibit-startup-screen t)
+ '(package-selected-packages (quote (elpy forest-blue-theme)))
+ '(pyvenv-activate "~/.virtualenv/default"))
+
+ ;; https://github.com/Boruch-Baum
+(defun my-copy-to-xclipboard(arg)
+      (interactive "P")
+      (cond
+       ((not (use-region-p))
+	 (message "Nothing to yank to X-clipboard"))
+        ((and (not (display-graphic-p))
+	      (/= 0 (shell-command-on-region
+		    (region-beginning) (region-end) "xsel -i -b")))
+	 (error "Is program `xsel' installed?"))
+        (t
+	 (when (display-graphic-p)
+            (call-interactively 'clipboard-kill-ring-save))
+          (message "Yanked region to X-clipboard")
+          (when arg
+            (kill-region  (region-beginning) (region-end)))
+          (deactivate-mark))))
+    
+(defun my-cut-to-xclipboard()
+      (interactive)
+      (my-copy-to-xclipboard t))
+    
+(defun my-paste-from-xclipboard()
+      "Uses shell command `xsel -o' to paste from x-clipboard. With
+    one prefix arg, pastes from X-PRIMARY, and with two prefix args,
+    pastes from X-SECONDARY."
+      (interactive)
+      (if (display-graphic-p)
+	  (clipboard-yank)
+	(let*
+	   ((opt (prefix-numeric-value current-prefix-arg))
+          (opt (cond
+		((=  1 opt) "b")
+           ((=  4 opt) "p")
+           ((= 16 opt) "s"))))
+	 (insert (shell-command-to-string (concat "xsel -o -" opt))))))
+
+(global-set-key (kbd "C-c C-w") 'my-cut-to-xclipboard)
+(global-set-key (kbd "C-c M-w") 'my-copy-to-xclipboard)
+(global-set-key (kbd "C-c C-y") 'my-paste-from-xclipboard)
+
+(load-theme 'forest-blue t)
+(elpy-enable)
+(custom-set-faces
+ ;; custom-set-faces was added by Custom.
+ ;; If you edit it by hand, you could mess it up, so be careful.
+ ;; Your init file should contain only one such instance.
+ ;; If there is more than one, they won't work right.
+ )

.emacs.d/elpa/archives/gnu/archive-contents.signed

@@ -0,0 +1 @@
+Good signature from 474F05837FBDEF9B GNU ELPA Signing Agent <elpasign@elpa.gnu.org> (trust undefined) created at 2017-12-06T23:10:01+0100 using DSA

.emacs.d/elpa/company-20171122.716/company-abbrev.el

@@ -0,0 +1,50 @@
+;;; company-abbrev.el --- company-mode completion backend for abbrev
+
+;; Copyright (C) 2009-2011, 2015  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'abbrev)
+
+(defun company-abbrev-insert (match)
+  "Replace MATCH with the expanded abbrev."
+  (expand-abbrev))
+
+;;;###autoload
+(defun company-abbrev (command &optional arg &rest ignored)
+  "`company-mode' completion backend for abbrev."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-abbrev
+                                        'company-abbrev-insert))
+    (prefix (company-grab-symbol))
+    (candidates (nconc
+                 (delete "" (all-completions arg global-abbrev-table))
+                 (delete "" (all-completions arg local-abbrev-table))))
+    (meta (abbrev-expansion arg))))
+
+(provide 'company-abbrev)
+;;; company-abbrev.el ends here

.emacs.d/elpa/company-20171122.716/company-autoloads.el

@@ -0,0 +1,318 @@
+;;; company-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
+
+;;;### (autoloads nil "company" "company.el" (23071 43281 630231
+;;;;;;  946000))
+;;; Generated autoloads from company.el
+
+(autoload 'company-mode "company" "\
+\"complete anything\"; is an in-buffer completion framework.
+Completion starts automatically, depending on the values
+`company-idle-delay' and `company-minimum-prefix-length'.
+
+Completion can be controlled with the commands:
+`company-complete-common', `company-complete-selection', `company-complete',
+`company-select-next', `company-select-previous'.  If these commands are
+called before `company-idle-delay', completion will also start.
+
+Completions can be searched with `company-search-candidates' or
+`company-filter-candidates'.  These can be used while completion is
+inactive, as well.
+
+The completion data is retrieved using `company-backends' and displayed
+using `company-frontends'.  If you want to start a specific backend, call
+it interactively or use `company-begin-backend'.
+
+By default, the completions list is sorted alphabetically, unless the
+backend chooses otherwise, or `company-transformers' changes it later.
+
+regular keymap (`company-mode-map'):
+
+\\{company-mode-map}
+keymap during active completions (`company-active-map'):
+
+\\{company-active-map}
+
+\(fn &optional ARG)" t nil)
+
+(defvar global-company-mode nil "\
+Non-nil if Global Company mode is enabled.
+See the `global-company-mode' command
+for a description of this minor mode.
+Setting this variable directly does not take effect;
+either customize it (see the info node `Easy Customization')
+or call the function `global-company-mode'.")
+
+(custom-autoload 'global-company-mode "company" nil)
+
+(autoload 'global-company-mode "company" "\
+Toggle Company mode in all buffers.
+With prefix ARG, enable Global Company mode if ARG is positive;
+otherwise, disable it.  If called from Lisp, enable the mode if
+ARG is omitted or nil.
+
+Company mode is enabled in all buffers where
+`company-mode-on' would do it.
+See `company-mode' for more information on Company mode.
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'company-manual-begin "company" "\
+
+
+\(fn)" t nil)
+
+(autoload 'company-complete "company" "\
+Insert the common part of all candidates or the current selection.
+The first time this is called, the common part is inserted, the second
+time, or when the selection has been changed, the selected candidate is
+inserted.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-abbrev" "company-abbrev.el" (23071
+;;;;;;  43281 766896 348000))
+;;; Generated autoloads from company-abbrev.el
+
+(autoload 'company-abbrev "company-abbrev" "\
+`company-mode' completion backend for abbrev.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-bbdb" "company-bbdb.el" (23071 43281
+;;;;;;  720230 455000))
+;;; Generated autoloads from company-bbdb.el
+
+(autoload 'company-bbdb "company-bbdb" "\
+`company-mode' completion backend for BBDB.
+
+\(fn COMMAND &optional ARG &rest IGNORE)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-css" "company-css.el" (23071 43281
+;;;;;;  620232 111000))
+;;; Generated autoloads from company-css.el
+
+(autoload 'company-css "company-css" "\
+`company-mode' completion backend for `css-mode'.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-dabbrev" "company-dabbrev.el" (23071
+;;;;;;  43281 670231 283000))
+;;; Generated autoloads from company-dabbrev.el
+
+(autoload 'company-dabbrev "company-dabbrev" "\
+dabbrev-like `company-mode' completion backend.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-dabbrev-code" "company-dabbrev-code.el"
+;;;;;;  (23071 43281 653564 892000))
+;;; Generated autoloads from company-dabbrev-code.el
+
+(autoload 'company-dabbrev-code "company-dabbrev-code" "\
+dabbrev-like `company-mode' backend for code.
+The backend looks for all symbols in the current buffer that aren't in
+comments or strings.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-elisp" "company-elisp.el" (23071 43281
+;;;;;;  786896 17000))
+;;; Generated autoloads from company-elisp.el
+
+(autoload 'company-elisp "company-elisp" "\
+`company-mode' completion backend for Emacs Lisp.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-etags" "company-etags.el" (23071 43281
+;;;;;;  636898 502000))
+;;; Generated autoloads from company-etags.el
+
+(autoload 'company-etags "company-etags" "\
+`company-mode' completion backend for etags.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-files" "company-files.el" (23071 43281
+;;;;;;  676897 839000))
+;;; Generated autoloads from company-files.el
+
+(autoload 'company-files "company-files" "\
+`company-mode' completion backend existing file names.
+Completions works for proper absolute and relative files paths.
+File paths with spaces are only supported inside strings.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-gtags" "company-gtags.el" (23071 43281
+;;;;;;  580232 773000))
+;;; Generated autoloads from company-gtags.el
+
+(autoload 'company-gtags "company-gtags" "\
+`company-mode' completion backend for GNU Global.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-ispell" "company-ispell.el" (23071
+;;;;;;  43281 776896 183000))
+;;; Generated autoloads from company-ispell.el
+
+(autoload 'company-ispell "company-ispell" "\
+`company-mode' completion backend using Ispell.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-keywords" "company-keywords.el" (23071
+;;;;;;  43281 696897 508000))
+;;; Generated autoloads from company-keywords.el
+
+(autoload 'company-keywords "company-keywords" "\
+`company-mode' backend for programming language keywords.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-nxml" "company-nxml.el" (23071 43281
+;;;;;;  740230 123000))
+;;; Generated autoloads from company-nxml.el
+
+(autoload 'company-nxml "company-nxml" "\
+`company-mode' completion backend for `nxml-mode'.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-oddmuse" "company-oddmuse.el" (23071
+;;;;;;  43281 603565 721000))
+;;; Generated autoloads from company-oddmuse.el
+
+(autoload 'company-oddmuse "company-oddmuse" "\
+`company-mode' completion backend for `oddmuse-mode'.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-semantic" "company-semantic.el" (23071
+;;;;;;  43281 590232 608000))
+;;; Generated autoloads from company-semantic.el
+
+(autoload 'company-semantic "company-semantic" "\
+`company-mode' completion backend using CEDET Semantic.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-tempo" "company-tempo.el" (23071 43281
+;;;;;;  660231 448000))
+;;; Generated autoloads from company-tempo.el
+
+(autoload 'company-tempo "company-tempo" "\
+`company-mode' completion backend for tempo.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-tng" "company-tng.el" (23071 43281
+;;;;;;  730230 289000))
+;;; Generated autoloads from company-tng.el
+
+(autoload 'company-tng-frontend "company-tng" "\
+When the user changes the selection at least once, this
+frontend will display the candidate in the buffer as if it's
+already there and any key outside of `company-active-map' will
+confirm the selection and finish the completion.
+
+\(fn COMMAND)" nil nil)
+
+(autoload 'company-tng-configure-default "company-tng" "\
+Applies the default configuration to enable company-tng.
+
+\(fn)" nil nil)
+
+;;;***
+
+;;;### (autoloads nil "company-xcode" "company-xcode.el" (23071 43281
+;;;;;;  756896 514000))
+;;; Generated autoloads from company-xcode.el
+
+(autoload 'company-xcode "company-xcode" "\
+`company-mode' completion backend for Xcode projects.
+
+\(fn COMMAND &optional ARG &rest IGNORED)" t nil)
+
+;;;***
+
+;;;### (autoloads nil "company-yasnippet" "company-yasnippet.el"
+;;;;;;  (23071 43281 750229 958000))
+;;; Generated autoloads from company-yasnippet.el
+
+(autoload 'company-yasnippet "company-yasnippet" "\
+`company-mode' backend for `yasnippet'.
+
+This backend should be used with care, because as long as there are
+snippets defined for the current major mode, this backend will always
+shadow backends that come after it.  Recommended usages:
+
+* In a buffer-local value of `company-backends', grouped with a backend or
+  several that provide actual text completions.
+
+  (add-hook 'js-mode-hook
+            (lambda ()
+              (set (make-local-variable 'company-backends)
+                   '((company-dabbrev-code company-yasnippet)))))
+
+* After keyword `:with', grouped with other backends.
+
+  (push '(company-semantic :with company-yasnippet) company-backends)
+
+* Not in `company-backends', just bound to a key.
+
+  (global-set-key (kbd \"C-c y\") 'company-yasnippet)
+
+\(fn COMMAND &optional ARG &rest IGNORE)" t nil)
+
+;;;***
+
+;;;### (autoloads nil nil ("company-capf.el" "company-clang.el" "company-cmake.el"
+;;;;;;  "company-eclim.el" "company-pkg.el" "company-template.el")
+;;;;;;  (23071 43281 706897 342000))
+
+;;;***
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; End:
+;;; company-autoloads.el ends here

.emacs.d/elpa/company-20171122.716/company-bbdb.el

@@ -0,0 +1,61 @@
+;;; company-bbdb.el --- company-mode completion backend for BBDB in message-mode
+
+;; Copyright (C) 2013-2014, 2016  Free Software Foundation, Inc.
+
+;; Author: Jan Tatarik <jan.tatarik@gmail.com>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+(require 'company)
+(require 'cl-lib)
+
+(declare-function bbdb-record-get-field "bbdb")
+(declare-function bbdb-records "bbdb")
+(declare-function bbdb-dwim-mail "bbdb-com")
+(declare-function bbdb-search "bbdb-com")
+
+(defgroup company-bbdb nil
+  "Completion backend for BBDB."
+  :group 'company)
+
+(defcustom company-bbdb-modes '(message-mode)
+  "Major modes in which `company-bbdb' may complete."
+  :type '(repeat (symbol :tag "Major mode"))
+  :package-version '(company . "0.8.8"))
+
+(defun company-bbdb--candidates (arg)
+  (cl-mapcan (lambda (record)
+               (mapcar (lambda (mail) (bbdb-dwim-mail record mail))
+                       (bbdb-record-get-field record 'mail)))
+             (eval '(bbdb-search (bbdb-records) arg nil arg))))
+
+;;;###autoload
+(defun company-bbdb (command &optional arg &rest ignore)
+  "`company-mode' completion backend for BBDB."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-bbdb))
+    (prefix (and (memq major-mode company-bbdb-modes)
+                 (featurep 'bbdb-com)
+                 (looking-back "^\\(To\\|Cc\\|Bcc\\): *.*? *\\([^,;]*\\)"
+                               (line-beginning-position))
+                 (match-string-no-properties 2)))
+    (candidates (company-bbdb--candidates arg))
+    (sorted t)
+    (no-cache t)))
+
+(provide 'company-bbdb)
+;;; company-bbdb.el ends here

.emacs.d/elpa/company-20171122.716/company-capf.el

@@ -0,0 +1,167 @@
+;;; company-capf.el --- company-mode completion-at-point-functions backend -*- lexical-binding: t -*-
+
+;; Copyright (C) 2013-2016  Free Software Foundation, Inc.
+
+;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defvar company--capf-cache nil)
+
+(defun company--capf-data ()
+  (let ((cache company--capf-cache))
+    (if (and (equal (current-buffer) (car cache))
+             (equal (point) (car (setq cache (cdr cache))))
+             (equal (buffer-chars-modified-tick) (car (setq cache (cdr cache)))))
+        (cadr cache)
+      (let ((data (company--capf-data-real)))
+        (setq company--capf-cache
+              (list (current-buffer) (point) (buffer-chars-modified-tick) data))
+        data))))
+
+(defun company--capf-data-real ()
+  (cl-letf* (((default-value 'completion-at-point-functions)
+              ;; Ignore tags-completion-at-point-function because it subverts
+              ;; company-etags in the default value of company-backends, where
+              ;; the latter comes later.
+              (remove 'tags-completion-at-point-function
+                      (default-value 'completion-at-point-functions)))
+             (completion-at-point-functions (company--capf-workaround))
+             (data (run-hook-wrapped 'completion-at-point-functions
+                                     ;; Ignore misbehaving functions.
+                                     #'completion--capf-wrapper 'optimist)))
+    (when (and (consp (cdr data)) (integer-or-marker-p (nth 1 data))) data)))
+
+(declare-function python-shell-get-process "python")
+
+(defun company--capf-workaround ()
+  ;; For http://debbugs.gnu.org/cgi/bugreport.cgi?bug=18067
+  (if (or (not (listp completion-at-point-functions))
+          (not (memq 'python-completion-complete-at-point completion-at-point-functions))
+          (python-shell-get-process))
+      completion-at-point-functions
+    (remq 'python-completion-complete-at-point completion-at-point-functions)))
+
+(defun company-capf (command &optional arg &rest _args)
+  "`company-mode' backend using `completion-at-point-functions'."
+  (interactive (list 'interactive))
+  (pcase command
+    (`interactive (company-begin-backend 'company-capf))
+    (`prefix
+     (let ((res (company--capf-data)))
+       (when res
+         (let ((length (plist-get (nthcdr 4 res) :company-prefix-length))
+               (prefix (buffer-substring-no-properties (nth 1 res) (point))))
+           (cond
+            ((> (nth 2 res) (point)) 'stop)
+            (length (cons prefix length))
+            (t prefix))))))
+    (`candidates
+     (let ((res (company--capf-data)))
+       (when res
+         (let* ((table (nth 3 res))
+                (pred (plist-get (nthcdr 4 res) :predicate))
+                (meta (completion-metadata
+                      (buffer-substring (nth 1 res) (nth 2 res))
+                      table pred))
+                (sortfun (cdr (assq 'display-sort-function meta)))
+                (candidates (completion-all-completions arg table pred (length arg)))
+                (last (last candidates))
+                (base-size (and (numberp (cdr last)) (cdr last))))
+           (when base-size
+             (setcdr last nil))
+           (when sortfun
+             (setq candidates (funcall sortfun candidates)))
+           (if (not (zerop (or base-size 0)))
+               (let ((before (substring arg 0 base-size)))
+                 (mapcar (lambda (candidate)
+                           (concat before candidate))
+                         candidates))
+             candidates)))))
+    (`sorted
+     (let ((res (company--capf-data)))
+       (when res
+         (let ((meta (completion-metadata
+                      (buffer-substring (nth 1 res) (nth 2 res))
+                      (nth 3 res) (plist-get (nthcdr 4 res) :predicate))))
+           (cdr (assq 'display-sort-function meta))))))
+    (`match
+     ;; Can't just use 0 when base-size (see above) is non-zero.
+     (let ((start (if (get-text-property 0 'face arg)
+                      0
+                    (next-single-property-change 0 'face arg))))
+       (when start
+         ;; completions-common-part comes first, but we can't just look for this
+         ;; value because it can be in a list.
+         (or
+          (let ((value (get-text-property start 'face arg)))
+            (text-property-not-all start (length arg)
+                                   'face value arg))
+          (length arg)))))
+    (`duplicates t)
+    (`no-cache t)   ;Not much can be done here, as long as we handle
+                    ;non-prefix matches.
+    (`meta
+     (let ((f (plist-get (nthcdr 4 (company--capf-data)) :company-docsig)))
+       (when f (funcall f arg))))
+    (`doc-buffer
+     (let ((f (plist-get (nthcdr 4 (company--capf-data)) :company-doc-buffer)))
+       (when f (funcall f arg))))
+    (`location
+     (let ((f (plist-get (nthcdr 4 (company--capf-data)) :company-location)))
+       (when f (funcall f arg))))
+    (`annotation
+     (save-excursion
+       ;; FIXME: `company-begin' sets `company-point' after calling
+       ;; `company--begin-new'.  We shouldn't rely on `company-point' here,
+       ;; better to cache the capf-data value instead.  However: we can't just
+       ;; save the last capf-data value in `prefix', because that command can
+       ;; get called more often than `candidates', and at any point in the
+       ;; buffer (https://github.com/company-mode/company-mode/issues/153).
+       ;; We could try propertizing the returned prefix string, but it's not
+       ;; passed to `annotation', and `company-prefix' is set only after
+       ;; `company--strip-duplicates' is called.
+       (when company-point
+         (goto-char company-point))
+       (let ((f (plist-get (nthcdr 4 (company--capf-data)) :annotation-function)))
+         (when f (funcall f arg)))))
+    (`require-match
+     (plist-get (nthcdr 4 (company--capf-data)) :company-require-match))
+    (`init nil)      ;Don't bother: plenty of other ways to initialize the code.
+    (`post-completion
+     (let* ((res (company--capf-data))
+            (exit-function (plist-get (nthcdr 4 res) :exit-function))
+            (table (nth 3 res))
+            (pred (plist-get (nthcdr 4 res) :predicate)))
+       (if exit-function
+           ;; Follow the example of `completion--done'.
+           (funcall exit-function arg
+                    (if (eq (try-completion arg table pred) t)
+                        'finished 'sole)))))
+    ))
+
+(provide 'company-capf)
+
+;;; company-capf.el ends here

.emacs.d/elpa/company-20171122.716/company-clang.el

@@ -0,0 +1,333 @@
+;;; company-clang.el --- company-mode completion backend for Clang  -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009, 2011, 2013-2016  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'company-template)
+(require 'cl-lib)
+
+(defgroup company-clang nil
+  "Completion backend for Clang."
+  :group 'company)
+
+(defcustom company-clang-executable
+  (executable-find "clang")
+  "Location of clang executable."
+  :type 'file)
+
+(defcustom company-clang-begin-after-member-access t
+  "When non-nil, automatic completion will start whenever the current
+symbol is preceded by \".\", \"->\" or \"::\", ignoring
+`company-minimum-prefix-length'.
+
+If `company-begin-commands' is a list, it should include `c-electric-lt-gt'
+and `c-electric-colon', for automatic completion right after \">\" and
+\":\".")
+
+(defcustom company-clang-arguments nil
+  "Additional arguments to pass to clang when completing.
+Prefix files (-include ...) can be selected with `company-clang-set-prefix'
+or automatically through a custom `company-clang-prefix-guesser'."
+  :type '(repeat (string :tag "Argument")))
+
+(defcustom company-clang-prefix-guesser 'company-clang-guess-prefix
+  "A function to determine the prefix file for the current buffer."
+  :type '(function :tag "Guesser function" nil))
+
+(defvar company-clang-modes '(c-mode c++-mode objc-mode)
+  "Major modes which clang may complete.")
+
+(defcustom company-clang-insert-arguments t
+  "When non-nil, insert function arguments as a template after completion."
+  :type 'boolean
+  :package-version '(company . "0.8.0"))
+
+;; prefix ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar company-clang--prefix nil)
+
+(defsubst company-clang--guess-pch-file (file)
+  (let ((dir (directory-file-name (file-name-directory file))))
+    (when (equal (file-name-nondirectory dir) "Classes")
+      (setq dir (file-name-directory dir)))
+    (car (directory-files dir t "\\([^.]h\\|[^h]\\).pch\\'" t))))
+
+(defsubst company-clang--file-substring (file beg end)
+  (with-temp-buffer
+    (insert-file-contents-literally file nil beg end)
+    (buffer-string)))
+
+(defun company-clang-guess-prefix ()
+  "Try to guess the prefix file for the current buffer."
+  ;; Prefixes seem to be called .pch.  Pre-compiled headers do, too.
+  ;; So we look at the magic number to rule them out.
+  (let* ((file (company-clang--guess-pch-file buffer-file-name))
+         (magic-number (and file (company-clang--file-substring file 0 4))))
+    (unless (member magic-number '("CPCH" "gpch"))
+      file)))
+
+(defun company-clang-set-prefix (&optional prefix)
+  "Use PREFIX as a prefix (-include ...) file for clang completion."
+  (interactive (let ((def (funcall company-clang-prefix-guesser)))
+     (unless (stringp def)
+       (setq def default-directory))
+     (list (read-file-name "Prefix file: "
+                           (when def (file-name-directory def))
+                           def t (when def (file-name-nondirectory def))))))
+  ;; TODO: pre-compile?
+  (setq company-clang--prefix (and (stringp prefix)
+                                   (file-regular-p prefix)
+                                   prefix)))
+
+;; Clean-up on exit.
+(add-hook 'kill-emacs-hook 'company-clang-set-prefix)
+
+;; parsing ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+;; TODO: Handle Pattern (syntactic hints would be neat).
+;; Do we ever see OVERLOAD (or OVERRIDE)?
+(defconst company-clang--completion-pattern
+  "^COMPLETION: \\_<\\(%s[a-zA-Z0-9_:]*\\)\\(?: : \\(.*\\)$\\)?$")
+
+(defconst company-clang--error-buffer-name "*clang-error*")
+
+(defun company-clang--lang-option ()
+     (if (eq major-mode 'objc-mode)
+         (if (string= "m" (file-name-extension buffer-file-name))
+             "objective-c" "objective-c++")
+       (substring (symbol-name major-mode) 0 -5)))
+
+(defun company-clang--parse-output (prefix _objc)
+  (goto-char (point-min))
+  (let ((pattern (format company-clang--completion-pattern
+                         (regexp-quote prefix)))
+        (case-fold-search nil)
+        lines match)
+    (while (re-search-forward pattern nil t)
+      (setq match (match-string-no-properties 1))
+      (unless (equal match "Pattern")
+        (save-match-data
+          (when (string-match ":" match)
+            (setq match (substring match 0 (match-beginning 0)))))
+        (let ((meta (match-string-no-properties 2)))
+          (when (and meta (not (string= match meta)))
+            (put-text-property 0 1 'meta
+                               (company-clang--strip-formatting meta)
+                               match)))
+        (push match lines)))
+    lines))
+
+(defun company-clang--meta (candidate)
+  (get-text-property 0 'meta candidate))
+
+(defun company-clang--annotation (candidate)
+  (let ((ann (company-clang--annotation-1 candidate)))
+    (if (not (and ann (string-prefix-p "(*)" ann)))
+        ann
+      (with-temp-buffer
+        (insert ann)
+        (search-backward ")")
+        (let ((pt (1+ (point))))
+          (re-search-forward ".\\_>" nil t)
+          (delete-region pt (point)))
+        (buffer-string)))))
+
+(defun company-clang--annotation-1 (candidate)
+  (let ((meta (company-clang--meta candidate)))
+    (cond
+     ((null meta) nil)
+     ((string-match "[^:]:[^:]" meta)
+      (substring meta (1+ (match-beginning 0))))
+     ((string-match "(anonymous)" meta) nil)
+     ((string-match "\\((.*)[ a-z]*\\'\\)" meta)
+      (let ((paren (match-beginning 1)))
+        (if (not (eq (aref meta (1- paren)) ?>))
+            (match-string 1 meta)
+          (with-temp-buffer
+            (insert meta)
+            (goto-char paren)
+            (substring meta (1- (search-backward "<"))))))))))
+
+(defun company-clang--strip-formatting (text)
+  (replace-regexp-in-string
+   "#]" " "
+   (replace-regexp-in-string "[<{[]#\\|#[>}]" "" text t)
+   t))
+
+(defun company-clang--handle-error (res args)
+  (goto-char (point-min))
+  (let* ((buf (get-buffer-create company-clang--error-buffer-name))
+         (cmd (concat company-clang-executable " " (mapconcat 'identity args " ")))
+         (pattern (format company-clang--completion-pattern ""))
+         (err (if (re-search-forward pattern nil t)
+                  (buffer-substring-no-properties (point-min)
+                                                  (1- (match-beginning 0)))
+                ;; Warn the user more aggressively if no match was found.
+                (message "clang failed with error %d:\n%s" res cmd)
+                (buffer-string))))
+
+    (with-current-buffer buf
+      (let ((inhibit-read-only t))
+        (erase-buffer)
+        (insert (current-time-string)
+                (format "\nclang failed with error %d:\n" res)
+                cmd "\n\n")
+        (insert err)
+        (setq buffer-read-only t)
+        (goto-char (point-min))))))
+
+(defun company-clang--start-process (prefix callback &rest args)
+  (let ((objc (derived-mode-p 'objc-mode))
+        (buf (get-buffer-create "*clang-output*"))
+        ;; Looks unnecessary in Emacs 25.1 and later.
+        (process-adaptive-read-buffering nil))
+    (if (get-buffer-process buf)
+        (funcall callback nil)
+      (with-current-buffer buf
+        (erase-buffer)
+        (setq buffer-undo-list t))
+      (let* ((process-connection-type nil)
+             (process (apply #'start-file-process "company-clang" buf
+                             company-clang-executable args)))
+        (set-process-sentinel
+         process
+         (lambda (proc status)
+           (unless (string-match-p "hangup" status)
+             (funcall
+              callback
+              (let ((res (process-exit-status proc)))
+                (with-current-buffer buf
+                  (unless (eq 0 res)
+                    (company-clang--handle-error res args))
+                  ;; Still try to get any useful input.
+                  (company-clang--parse-output prefix objc)))))))
+        (unless (company-clang--auto-save-p)
+          (send-region process (point-min) (point-max))
+          (send-string process "\n")
+          (process-send-eof process))))))
+
+(defsubst company-clang--build-location (pos)
+  (save-excursion
+    (goto-char pos)
+    (format "%s:%d:%d"
+            (if (company-clang--auto-save-p) buffer-file-name "-")
+            (line-number-at-pos)
+            (1+ (length
+                 (encode-coding-region
+                  (line-beginning-position)
+                  (point)
+                  'utf-8
+                  t))))))
+
+(defsubst company-clang--build-complete-args (pos)
+  (append '("-fsyntax-only" "-Xclang" "-code-completion-macros")
+          (unless (company-clang--auto-save-p)
+            (list "-x" (company-clang--lang-option)))
+          company-clang-arguments
+          (when (stringp company-clang--prefix)
+            (list "-include" (expand-file-name company-clang--prefix)))
+          (list "-Xclang" (format "-code-completion-at=%s"
+                                  (company-clang--build-location pos)))
+          (list (if (company-clang--auto-save-p) buffer-file-name "-"))))
+
+(defun company-clang--candidates (prefix callback)
+  (and (company-clang--auto-save-p)
+       (buffer-modified-p)
+       (basic-save-buffer))
+  (when (null company-clang--prefix)
+    (company-clang-set-prefix (or (funcall company-clang-prefix-guesser)
+                                  'none)))
+  (apply 'company-clang--start-process
+         prefix
+         callback
+         (company-clang--build-complete-args (point))))
+
+(defun company-clang--prefix ()
+  (if company-clang-begin-after-member-access
+      (company-grab-symbol-cons "\\.\\|->\\|::" 2)
+    (company-grab-symbol)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defconst company-clang-required-version 1.1)
+
+(defvar company-clang--version nil)
+
+(defun company-clang--auto-save-p ()
+  (< company-clang--version 2.9))
+
+(defsubst company-clang-version ()
+  "Return the version of `company-clang-executable'."
+  (with-temp-buffer
+    (call-process company-clang-executable nil t nil "--version")
+    (goto-char (point-min))
+    (if (re-search-forward "clang\\(?: version \\|-\\)\\([0-9.]+\\)" nil t)
+        (let ((ver (string-to-number (match-string-no-properties 1))))
+          (if (> ver 100)
+              (/ ver 100)
+            ver))
+      0)))
+
+(defun company-clang (command &optional arg &rest ignored)
+  "`company-mode' completion backend for Clang.
+Clang is a parser for C and ObjC.  Clang version 1.1 or newer is required.
+
+Additional command line arguments can be specified in
+`company-clang-arguments'.  Prefix files (-include ...) can be selected
+with `company-clang-set-prefix' or automatically through a custom
+`company-clang-prefix-guesser'.
+
+With Clang versions before 2.9, we have to save the buffer before
+performing completion.  With Clang 2.9 and later, buffer contents are
+passed via standard input."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-clang))
+    (init (when (memq major-mode company-clang-modes)
+            (unless company-clang-executable
+              (error "Company found no clang executable"))
+            (setq company-clang--version (company-clang-version))
+            (when (< company-clang--version company-clang-required-version)
+              (error "Company requires clang version 1.1"))))
+    (prefix (and (memq major-mode company-clang-modes)
+                 buffer-file-name
+                 company-clang-executable
+                 (not (company-in-string-or-comment))
+                 (or (company-clang--prefix) 'stop)))
+    (candidates (cons :async
+                      (lambda (cb) (company-clang--candidates arg cb))))
+    (meta       (company-clang--meta arg))
+    (annotation (company-clang--annotation arg))
+    (post-completion (let ((anno (company-clang--annotation arg)))
+                       (when (and company-clang-insert-arguments anno)
+                         (insert anno)
+                         (if (string-match "\\`:[^:]" anno)
+                             (company-template-objc-templatify anno)
+                           (company-template-c-like-templatify
+                            (concat arg anno))))))))
+
+(provide 'company-clang)
+;;; company-clang.el ends here

.emacs.d/elpa/company-20171122.716/company-cmake.el

@@ -0,0 +1,198 @@
+;;; company-cmake.el --- company-mode completion backend for CMake
+
+;; Copyright (C) 2013-2014  Free Software Foundation, Inc.
+
+;; Author: Chen Bin <chenbin DOT sh AT gmail>
+;; Version: 0.2
+
+;; This program is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; company-cmake offers completions for module names, variable names and
+;; commands used by CMake.  And their descriptions.
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defgroup company-cmake nil
+  "Completion backend for CMake."
+  :group 'company)
+
+(defcustom company-cmake-executable
+  (executable-find "cmake")
+  "Location of cmake executable."
+  :type 'file)
+
+(defvar company-cmake-executable-arguments
+  '("--help-command-list"
+    "--help-module-list"
+    "--help-variable-list")
+  "The arguments we pass to cmake, separately.
+They affect which types of symbols we get completion candidates for.")
+
+(defvar company-cmake--completion-pattern
+  "^\\(%s[a-zA-Z0-9_<>]%s\\)$"
+  "Regexp to match the candidates.")
+
+(defvar company-cmake-modes '(cmake-mode)
+  "Major modes in which cmake may complete.")
+
+(defvar company-cmake--candidates-cache nil
+  "Cache for the raw candidates.")
+
+(defvar company-cmake--meta-command-cache nil
+  "Cache for command arguments to retrieve descriptions for the candidates.")
+
+(defun company-cmake--replace-tags (rlt)
+  (setq rlt (replace-regexp-in-string
+             "\\(.*?\\(IS_GNU\\)?\\)<LANG>\\(.*\\)"
+             (lambda (_match)
+               (mapconcat 'identity
+                          (if (match-beginning 2)
+                              '("\\1CXX\\3" "\\1C\\3" "\\1G77\\3")
+                            '("\\1CXX\\3" "\\1C\\3" "\\1Fortran\\3"))
+                          "\n"))
+             rlt t))
+  (setq rlt (replace-regexp-in-string
+             "\\(.*\\)<CONFIG>\\(.*\\)"
+             (mapconcat 'identity '("\\1DEBUG\\2" "\\1RELEASE\\2"
+                                    "\\1RELWITHDEBINFO\\2" "\\1MINSIZEREL\\2")
+                        "\n")
+             rlt))
+  rlt)
+
+(defun company-cmake--fill-candidates-cache (arg)
+  "Fill candidates cache if needed."
+  (let (rlt)
+    (unless company-cmake--candidates-cache
+      (setq company-cmake--candidates-cache (make-hash-table :test 'equal)))
+
+    ;; If hash is empty, fill it.
+    (unless (gethash arg company-cmake--candidates-cache)
+      (with-temp-buffer
+        (let ((res (call-process company-cmake-executable nil t nil arg)))
+          (unless (zerop res)
+            (message "cmake executable exited with error=%d" res)))
+        (setq rlt (buffer-string)))
+      (setq rlt (company-cmake--replace-tags rlt))
+      (puthash arg rlt company-cmake--candidates-cache))
+    ))
+
+(defun company-cmake--parse (prefix content cmd)
+  (let ((start 0)
+        (pattern (format company-cmake--completion-pattern
+                         (regexp-quote prefix)
+                         (if (zerop (length prefix)) "+" "*")))
+        (lines (split-string content "\n"))
+        match
+        rlt)
+    (dolist (line lines)
+      (when (string-match pattern line)
+        (let ((match (match-string 1 line)))
+          (when match
+            (puthash match cmd company-cmake--meta-command-cache)
+            (push match rlt)))))
+    rlt))
+
+(defun company-cmake--candidates (prefix)
+  (let (results
+        cmd-opts
+        str)
+
+    (unless company-cmake--meta-command-cache
+      (setq company-cmake--meta-command-cache (make-hash-table :test 'equal)))
+
+    (dolist (arg company-cmake-executable-arguments)
+      (company-cmake--fill-candidates-cache arg)
+      (setq cmd-opts (replace-regexp-in-string "-list$" "" arg) )
+
+      (setq str (gethash arg company-cmake--candidates-cache))
+      (when str
+        (setq results (nconc results
+                             (company-cmake--parse prefix str cmd-opts)))))
+    results))
+
+(defun company-cmake--unexpand-candidate (candidate)
+  (cond
+   ((string-match "^CMAKE_\\(C\\|CXX\\|Fortran\\)\\(_.*\\)$" candidate)
+    (setq candidate (concat "CMAKE_<LANG>" (match-string 2 candidate))))
+
+   ;; C flags
+   ((string-match "^\\(.*_\\)IS_GNU\\(C\\|CXX\\|G77\\)$" candidate)
+    (setq candidate (concat (match-string 1 candidate) "IS_GNU<LANG>")))
+
+   ;; C flags
+   ((string-match "^\\(.*_\\)OVERRIDE_\\(C\\|CXX\\|Fortran\\)$" candidate)
+    (setq candidate (concat (match-string 1 candidate) "OVERRIDE_<LANG>")))
+
+   ((string-match "^\\(.*\\)\\(_DEBUG\\|_RELEASE\\|_RELWITHDEBINFO\\|_MINSIZEREL\\)\\(.*\\)$" candidate)
+    (setq candidate (concat (match-string 1 candidate)
+                            "_<CONFIG>"
+                            (match-string 3 candidate)))))
+  candidate)
+
+(defun company-cmake--meta (candidate)
+  (let ((cmd-opts (gethash candidate company-cmake--meta-command-cache))
+        result)
+    (setq candidate (company-cmake--unexpand-candidate candidate))
+
+    ;; Don't cache the documentation of every candidate (command)
+    ;; Cache in this case will cost too much memory.
+    (with-temp-buffer
+      (call-process company-cmake-executable nil t nil cmd-opts candidate)
+      ;; Go to the third line, trim it and return the result.
+      ;; Tested with cmake 2.8.9.
+      (goto-char (point-min))
+      (forward-line 2)
+      (setq result (buffer-substring-no-properties (line-beginning-position)
+                                                   (line-end-position)))
+      (setq result (replace-regexp-in-string "^[ \t\n\r]+" "" result))
+      result)))
+
+(defun company-cmake--doc-buffer (candidate)
+  (let ((cmd-opts (gethash candidate company-cmake--meta-command-cache)))
+
+    (setq candidate (company-cmake--unexpand-candidate candidate))
+    (with-temp-buffer
+      (call-process company-cmake-executable nil t nil cmd-opts candidate)
+      ;; Go to the third line, trim it and return the doc buffer.
+      ;; Tested with cmake 2.8.9.
+      (goto-char (point-min))
+      (forward-line 2)
+      (company-doc-buffer
+       (buffer-substring-no-properties (line-beginning-position)
+                                       (point-max))))))
+
+(defun company-cmake (command &optional arg &rest ignored)
+  "`company-mode' completion backend for CMake.
+CMake is a cross-platform, open-source make system."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-cmake))
+    (init (when (memq major-mode company-cmake-modes)
+            (unless company-cmake-executable
+              (error "Company found no cmake executable"))))
+    (prefix (and (memq major-mode company-cmake-modes)
+                 (not (company-in-string-or-comment))
+                 (company-grab-symbol)))
+    (candidates (company-cmake--candidates arg))
+    (meta (company-cmake--meta arg))
+    (doc-buffer (company-cmake--doc-buffer arg))
+    ))
+
+(provide 'company-cmake)
+;;; company-cmake.el ends here

.emacs.d/elpa/company-20171122.716/company-css.el

@@ -0,0 +1,442 @@
+;;; company-css.el --- company-mode completion backend for css-mode  -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009, 2011, 2014  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(declare-function web-mode-language-at-pos "web-mode" (&optional pos))
+
+(defconst company-css-property-alist
+  ;; see http://www.w3.org/TR/CSS21/propidx.html
+  '(("azimuth" angle "left-side" "far-left" "left" "center-left" "center"
+     "center-right" "right" "far-right" "right-side" "behind" "leftwards"
+     "rightwards")
+    ("background" background-color background-image background-repeat
+     background-attachment background-position
+     background-clip background-origin background-size)
+    ("background-attachment" "scroll" "fixed")
+    ("background-color" color "transparent")
+    ("background-image" uri "none")
+    ("background-position" percentage length "left" "center" "right" percentage
+     length "top" "center" "bottom" "left" "center" "right" "top" "center"
+     "bottom")
+    ("background-repeat" "repeat" "repeat-x" "repeat-y" "no-repeat")
+    ("border" border-width border-style border-color)
+    ("border-bottom" border)
+    ("border-bottom-color" border-color)
+    ("border-bottom-style" border-style)
+    ("border-bottom-width" border-width)
+    ("border-collapse" "collapse" "separate")
+    ("border-color" color "transparent")
+    ("border-left" border)
+    ("border-left-color" border-color)
+    ("border-left-style" border-style)
+    ("border-left-width" border-width)
+    ("border-right" border)
+    ("border-right-color" border-color)
+    ("border-right-style" border-style)
+    ("border-right-width" border-width)
+    ("border-spacing" length length)
+    ("border-style" border-style)
+    ("border-top" border)
+    ("border-top-color" border-color)
+    ("border-top-style" border-style)
+    ("border-top-width" border-width)
+    ("border-width" border-width)
+    ("bottom" length percentage "auto")
+    ("caption-side" "top" "bottom")
+    ("clear" "none" "left" "right" "both")
+    ("clip" shape "auto")
+    ("color" color)
+    ("content" "normal" "none" string uri counter "attr()" "open-quote"
+     "close-quote" "no-open-quote" "no-close-quote")
+    ("counter-increment" identifier integer "none")
+    ("counter-reset" identifier integer "none")
+    ("cue" cue-before cue-after)
+    ("cue-after" uri "none")
+    ("cue-before" uri "none")
+    ("cursor" uri "*" "auto" "crosshair" "default" "pointer" "move" "e-resize"
+     "ne-resize" "nw-resize" "n-resize" "se-resize" "sw-resize" "s-resize"
+     "w-resize" "text" "wait" "help" "progress")
+    ("direction" "ltr" "rtl")
+    ("display" "inline" "block" "list-item" "run-in" "inline-block" "table"
+     "inline-table" "table-row-group" "table-header-group" "table-footer-group"
+     "table-row" "table-column-group" "table-column" "table-cell"
+     "table-caption" "none")
+    ("elevation" angle "below" "level" "above" "higher" "lower")
+    ("empty-cells" "show" "hide")
+    ("float" "left" "right" "none")
+    ("font" font-style font-weight font-size "/" line-height
+     font-family "caption" "icon" "menu" "message-box" "small-caption"
+     "status-bar" "normal" "small-caps"
+     ;; CSS3
+     font-stretch)
+    ("font-family" family-name generic-family)
+    ("font-size" absolute-size relative-size length percentage)
+    ("font-style" "normal" "italic" "oblique")
+    ("font-weight" "normal" "bold" "bolder" "lighter" "100" "200" "300" "400"
+     "500" "600" "700" "800" "900")
+    ("height" length percentage "auto")
+    ("left" length percentage "auto")
+    ("letter-spacing" "normal" length)
+    ("line-height" "normal" number length percentage)
+    ("list-style" list-style-type list-style-position list-style-image)
+    ("list-style-image" uri "none")
+    ("list-style-position" "inside" "outside")
+    ("list-style-type" "disc" "circle" "square" "decimal" "decimal-leading-zero"
+     "lower-roman" "upper-roman" "lower-greek" "lower-latin" "upper-latin"
+     "armenian" "georgian" "lower-alpha" "upper-alpha" "none")
+    ("margin" margin-width)
+    ("margin-bottom" margin-width)
+    ("margin-left" margin-width)
+    ("margin-right" margin-width)
+    ("margin-top" margin-width)
+    ("max-height" length percentage "none")
+    ("max-width" length percentage "none")
+    ("min-height" length percentage)
+    ("min-width" length percentage)
+    ("orphans" integer)
+    ("outline" outline-color outline-style outline-width)
+    ("outline-color" color "invert")
+    ("outline-style" border-style)
+    ("outline-width" border-width)
+    ("overflow" "visible" "hidden" "scroll" "auto"
+     ;; CSS3:
+     "no-display" "no-content")
+    ("padding" padding-width)
+    ("padding-bottom" padding-width)
+    ("padding-left" padding-width)
+    ("padding-right" padding-width)
+    ("padding-top" padding-width)
+    ("page-break-after" "auto" "always" "avoid" "left" "right")
+    ("page-break-before" "auto" "always" "avoid" "left" "right")
+    ("page-break-inside" "avoid" "auto")
+    ("pause" time percentage)
+    ("pause-after" time percentage)
+    ("pause-before" time percentage)
+    ("pitch" frequency "x-low" "low" "medium" "high" "x-high")
+    ("pitch-range" number)
+    ("play-during" uri "mix" "repeat" "auto" "none")
+    ("position" "static" "relative" "absolute" "fixed")
+    ("quotes" string string "none")
+    ("richness" number)
+    ("right" length percentage "auto")
+    ("speak" "normal" "none" "spell-out")
+    ("speak-header" "once" "always")
+    ("speak-numeral" "digits" "continuous")
+    ("speak-punctuation" "code" "none")
+    ("speech-rate" number "x-slow" "slow" "medium" "fast" "x-fast" "faster"
+     "slower")
+    ("stress" number)
+    ("table-layout" "auto" "fixed")
+    ("text-align" "left" "right" "center" "justify")
+    ("text-indent" length percentage)
+    ("text-transform" "capitalize" "uppercase" "lowercase" "none")
+    ("top" length percentage "auto")
+    ("unicode-bidi" "normal" "embed" "bidi-override")
+    ("vertical-align" "baseline" "sub" "super" "top" "text-top" "middle"
+     "bottom" "text-bottom" percentage length)
+    ("visibility" "visible" "hidden" "collapse")
+    ("voice-family" specific-voice generic-voice "*" specific-voice
+     generic-voice)
+    ("volume" number percentage "silent" "x-soft" "soft" "medium" "loud"
+     "x-loud")
+    ("white-space" "normal" "pre" "nowrap" "pre-wrap" "pre-line")
+    ("widows" integer)
+    ("width" length percentage "auto")
+    ("word-spacing" "normal" length)
+    ("z-index" "auto" integer)
+    ;; CSS3
+    ("align-content" align-stretch "space-between" "space-around")
+    ("align-items" align-stretch "baseline")
+    ("align-self" align-items "auto")
+    ("animation" animation-name animation-duration animation-timing-function
+     animation-delay animation-iteration-count animation-direction
+     animation-fill-mode)
+    ("animation-delay" time)
+    ("animation-direction" "normal" "reverse" "alternate" "alternate-reverse")
+    ("animation-duration" time)
+    ("animation-fill-mode" "none" "forwards" "backwards" "both")
+    ("animation-iteration-count" integer "infinite")
+    ("animation-name" "none")
+    ("animation-play-state" "paused" "running")
+    ("animation-timing-function" transition-timing-function
+     "step-start" "step-end" "steps(,)")
+    ("backface-visibility" "visible" "hidden")
+    ("background-clip" background-origin)
+    ("background-origin" "border-box" "padding-box" "content-box")
+    ("background-size" length percentage "auto" "cover" "contain")
+    ("border-image" border-image-outset border-image-repeat border-image-source
+     border-image-slice border-image-width)
+    ("border-image-outset" length)
+    ("border-image-repeat" "stretch" "repeat" "round" "space")
+    ("border-image-source" uri "none")
+    ("border-image-slice" length)
+    ("border-image-width" length percentage)
+    ("border-radius" length)
+    ("border-top-left-radius" length)
+    ("border-top-right-radius" length)
+    ("border-bottom-left-radius" length)
+    ("border-bottom-right-radius" length)
+    ("box-decoration-break" "slice" "clone")
+    ("box-shadow" length color)
+    ("box-sizing" "content-box" "border-box")
+    ("break-after" "auto" "always" "avoid" "left" "right" "page" "column"
+     "avoid-page" "avoid-column")
+    ("break-before" break-after)
+    ("break-inside" "avoid" "auto")
+    ("columns" column-width column-count)
+    ("column-count" integer)
+    ("column-fill" "auto" "balance")
+    ("column-gap" length "normal")
+    ("column-rule" column-rule-width column-rule-style column-rule-color)
+    ("column-rule-color" color)
+    ("column-rule-style" border-style)
+    ("column-rule-width" border-width)
+    ("column-span" "all" "none")
+    ("column-width" length "auto")
+    ("filter" url "blur()" "brightness()" "contrast()" "drop-shadow()"
+     "grayscale()" "hue-rotate()" "invert()" "opacity()" "saturate()" "sepia()")
+    ("flex" flex-grow flex-shrink flex-basis)
+    ("flex-basis" percentage length "auto")
+    ("flex-direction" "row" "row-reverse" "column" "column-reverse")
+    ("flex-flow" flex-direction flex-wrap)
+    ("flex-grow" number)
+    ("flex-shrink" number)
+    ("flex-wrap" "nowrap" "wrap" "wrap-reverse")
+    ("font-feature-setting" normal string number)
+    ("font-kerning" "auto" "normal" "none")
+    ("font-language-override" "normal" string)
+    ("font-size-adjust" "none" number)
+    ("font-stretch" "normal" "ultra-condensed" "extra-condensed" "condensed"
+     "semi-condensed" "semi-expanded" "expanded" "extra-expanded" "ultra-expanded")
+    ("font-synthesis" "none" "weight" "style")
+    ("font-variant" font-variant-alternates font-variant-caps
+     font-variant-east-asian font-variant-ligatures font-variant-numeric
+     font-variant-position)
+    ("font-variant-alternates" "normal" "historical-forms" "stylistic()"
+     "styleset()" "character-variant()" "swash()" "ornaments()" "annotation()")
+    ("font-variant-caps" "normal" "small-caps" "all-small-caps" "petite-caps"
+     "all-petite-caps" "unicase" "titling-caps")
+    ("font-variant-east-asian" "jis78" "jis83" "jis90" "jis04" "simplified"
+     "traditional" "full-width" "proportional-width" "ruby")
+    ("font-variant-ligatures" "normal" "none" "common-ligatures"
+     "no-common-ligatures" "discretionary-ligatures" "no-discretionary-ligatures"
+     "historical-ligatures" "no-historical-ligatures" "contextual" "no-contextual")
+    ("font-variant-numeric" "normal" "ordinal" "slashed-zero"
+     "lining-nums" "oldstyle-nums" "proportional-nums" "tabular-nums"
+     "diagonal-fractions" "stacked-fractions")
+    ("font-variant-position" "normal" "sub" "super")
+    ("hyphens" "none" "manual" "auto")
+    ("justify-content" align-common "space-between" "space-around")
+    ("line-break" "auto" "loose" "normal" "strict")
+    ("marquee-direction" "forward" "reverse")
+    ("marquee-play-count" integer "infinite")
+    ("marquee-speed" "slow" "normal" "fast")
+    ("marquee-style" "scroll" "slide" "alternate")
+    ("opacity" number)
+    ("order" number)
+    ("outline-offset" length)
+    ("overflow-x" overflow)
+    ("overflow-y" overflow)
+    ("overflow-style" "auto" "marquee-line" "marquee-block")
+    ("overflow-wrap" "normal" "break-word")
+    ("perspective" "none" length)
+    ("perspective-origin" percentage length "left" "center" "right" "top" "bottom")
+    ("resize" "none" "both" "horizontal" "vertical")
+    ("tab-size" integer length)
+    ("text-align-last" "auto" "start" "end" "left" "right" "center" "justify")
+    ("text-decoration" text-decoration-color text-decoration-line text-decoration-style)
+    ("text-decoration-color" color)
+    ("text-decoration-line" "none" "underline" "overline" "line-through" "blink")
+    ("text-decoration-style" "solid" "double" "dotted" "dashed" "wavy")
+    ("text-overflow" "clip" "ellipsis")
+    ("text-shadow" color length)
+    ("text-underline-position" "auto" "under" "left" "right")
+    ("transform" "matrix(,,,,,)" "translate(,)" "translateX()" "translateY()"
+     "scale()" "scaleX()" "scaleY()" "rotate()" "skewX()" "skewY()" "none")
+    ("transform-origin" perspective-origin)
+    ("transform-style" "flat" "preserve-3d")
+    ("transition" transition-property transition-duration
+     transition-timing-function transition-delay)
+    ("transition-delay" time)
+    ("transition-duration" time)
+    ("transition-timing-function"
+     "ease" "linear" "ease-in" "ease-out" "ease-in-out" "cubic-bezier(,,,)")
+    ("transition-property" "none" "all" identifier)
+    ("word-wrap" overflow-wrap)
+    ("word-break" "normal" "break-all" "keep-all"))
+  "A list of CSS properties and their possible values.")
+
+(defconst company-css-value-classes
+  '((absolute-size "xx-small" "x-small" "small" "medium" "large" "x-large"
+                   "xx-large")
+    (align-common "flex-start" "flex-end" "center")
+    (align-stretch align-common "stretch")
+    (border-style "none" "hidden" "dotted" "dashed" "solid" "double" "groove"
+                  "ridge" "inset" "outset")
+    (border-width "thick" "medium" "thin")
+    (color "aqua" "black" "blue" "fuchsia" "gray" "green" "lime" "maroon" "navy"
+           "olive" "orange" "purple" "red" "silver" "teal" "white" "yellow")
+    (counter "counter(,)")
+    (family-name "Courier" "Helvetica" "Times")
+    (generic-family "serif" "sans-serif" "cursive" "fantasy" "monospace")
+    (generic-voice "male" "female" "child")
+    (margin-width "auto") ;; length percentage
+    (relative-size "larger" "smaller")
+    (shape "rect(,,,)")
+    (uri "url()"))
+  "A list of CSS property value classes and their contents.")
+;; missing, because not completable
+;; <angle><frequency><identifier><integer><length><number><padding-width>
+;; <percentage><specific-voice><string><time><uri>
+
+(defconst company-css-html-tags
+  '("a" "abbr" "acronym" "address" "applet" "area" "b" "base" "basefont" "bdo"
+    "big" "blockquote" "body" "br" "button" "caption" "center" "cite" "code"
+    "col" "colgroup" "dd" "del" "dfn" "dir" "div" "dl" "dt" "em" "fieldset"
+    "font" "form" "frame" "frameset" "h1" "h2" "h3" "h4" "h5" "h6" "head" "hr"
+    "html" "i" "iframe" "img" "input" "ins" "isindex" "kbd" "label" "legend"
+    "li" "link" "map" "menu" "meta" "noframes" "noscript" "object" "ol"
+    "optgroup" "option" "p" "param" "pre" "q" "s" "samp" "script" "select"
+    "small" "span" "strike" "strong" "style" "sub" "sup" "table" "tbody" "td"
+    "textarea" "tfoot" "th" "thead" "title" "tr" "tt" "u" "ul" "var"
+    ;; HTML5
+    "section" "article" "aside" "header" "footer" "nav" "figure" "figcaption"
+    "time" "mark" "main")
+  "A list of HTML tags for use in CSS completion.")
+
+(defconst company-css-pseudo-classes
+  '("active" "after" "before" "first" "first-child" "first-letter" "first-line"
+    "focus" "hover" "lang" "left" "link" "right" "visited")
+  "Identifiers for CSS pseudo-elements and pseudo-classes.")
+
+(defconst company-css-property-cache (make-hash-table :size 115 :test 'equal))
+
+(defun company-css-property-values (attribute)
+  "Access the `company-css-property-alist' cached and flattened."
+  (or (gethash attribute company-css-property-cache)
+      (let (results)
+        (dolist (value (cdr (assoc attribute company-css-property-alist)))
+          (if (symbolp value)
+              (dolist (child (or (cdr (assoc value company-css-value-classes))
+                                 (company-css-property-values
+                                  (symbol-name value))))
+                (push child results))
+            (push value results)))
+        (setq results (sort results 'string<))
+        (puthash attribute
+                 (if (fboundp 'delete-consecutive-dups)
+                     (delete-consecutive-dups results)
+                   (delete-dups results))
+                 company-css-property-cache)
+        results)))
+
+;;; bracket detection
+
+(defconst company-css-braces-syntax-table
+  (let ((table (make-syntax-table)))
+    (setf (aref table ?{) '(4 . 125))
+    (setf (aref table ?}) '(5 . 123))
+    table)
+  "A syntax table giving { and } paren syntax.")
+
+(defun company-css-inside-braces-p ()
+  "Return non-nil, if point is within matched { and }."
+  (ignore-errors
+    (with-syntax-table company-css-braces-syntax-table
+      (let ((parse-sexp-ignore-comments t))
+        (scan-lists (point) -1 1)))))
+
+;;; tags
+(defconst company-css-tag-regexp
+  (concat "\\(?:\\`\\|}\\)[[:space:]]*"
+          ;; multiple
+          "\\(?:"
+          ;; previous tags:
+          "\\(?:#\\|\\_<[[:alpha:]]\\)[[:alnum:]-#]*\\(?:\\[[^]]*\\]\\)?"
+          ;; space or selectors
+          "\\(?:[[:space:]]+\\|[[:space:]]*[+,>][[:space:]]*\\)"
+          "\\)*"
+          "\\(\\(?:#\\|\\_<[[:alpha:]]\\)\\(?:[[:alnum:]-#]*\\_>\\)?\\_>\\|\\)"
+          "\\=")
+  "A regular expression matching CSS tags.")
+
+;;; pseudo id
+(defconst company-css-pseudo-regexp
+  (concat "\\(?:\\`\\|}\\)[[:space:]]*"
+          ;; multiple
+          "\\(?:"
+          ;; previous tags:
+          "\\(?:#\\|\\_<[[:alpha:]]\\)[[:alnum:]-#]*\\(?:\\[[^]]*\\]\\)?"
+          ;; space or delimiters
+          "\\(?:[[:space:]]+\\|[[:space:]]*[+,>][[:space:]]*\\)"
+          "\\)*"
+          "\\(?:\\(?:\\#\\|\\_<[[:alpha:]]\\)[[:alnum:]-#]*\\):"
+          "\\([[:alpha:]-]+\\_>\\|\\)\\_>\\=")
+  "A regular expression matching CSS pseudo classes.")
+
+;;; properties
+
+(defun company-css-grab-property ()
+  "Return the CSS property before point, if any.
+Returns \"\" if no property found, but feasible at this position."
+  (when (company-css-inside-braces-p)
+    (company-grab-symbol)))
+
+;;; values
+(defconst company-css-property-value-regexp
+  "\\_<\\([[:alpha:]-]+\\):\\(?:[^{};]*[[:space:]]+\\)?\\([^{};]*\\_>\\|\\)\\="
+  "A regular expression matching CSS tags.")
+
+;;;###autoload
+(defun company-css (command &optional arg &rest ignored)
+  "`company-mode' completion backend for `css-mode'."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-css))
+    (prefix (and (or (derived-mode-p 'css-mode)
+                     (and (derived-mode-p 'web-mode)
+                          (string= (web-mode-language-at-pos) "css")))
+                 (or (company-grab company-css-tag-regexp 1)
+                     (company-grab company-css-pseudo-regexp 1)
+                     (company-grab company-css-property-value-regexp 2)
+                     (company-css-grab-property))))
+    (candidates
+     (cond
+      ((company-grab company-css-tag-regexp 1)
+       (all-completions arg company-css-html-tags))
+      ((company-grab company-css-pseudo-regexp 1)
+       (all-completions arg company-css-pseudo-classes))
+      ((company-grab company-css-property-value-regexp 2)
+       (all-completions arg
+                        (company-css-property-values
+                         (company-grab company-css-property-value-regexp 1))))
+      ((company-css-grab-property)
+       (all-completions arg company-css-property-alist))))
+    (sorted t)))
+
+(provide 'company-css)
+;;; company-css.el ends here

.emacs.d/elpa/company-20171122.716/company-dabbrev-code.el

@@ -0,0 +1,104 @@
+;;; company-dabbrev-code.el --- dabbrev-like company-mode backend for code  -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009, 2011, 2014  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'company-dabbrev)
+(require 'cl-lib)
+
+(defgroup company-dabbrev-code nil
+  "dabbrev-like completion backend for code."
+  :group 'company)
+
+(defcustom company-dabbrev-code-modes
+  '(prog-mode
+    batch-file-mode csharp-mode css-mode erlang-mode haskell-mode jde-mode
+    lua-mode python-mode)
+  "Modes that use `company-dabbrev-code'.
+In all these modes (and their derivatives) `company-dabbrev-code' will
+complete only symbols, not text in comments or strings.  In other modes
+`company-dabbrev-code' will pass control to other backends
+\(e.g. `company-dabbrev'\).  Value t means complete in all modes."
+  :type '(choice (repeat :tag "Some modes" (symbol :tag "Major mode"))
+                 (const :tag "All modes" t)))
+
+(defcustom company-dabbrev-code-other-buffers t
+  "Determines whether `company-dabbrev-code' should search other buffers.
+If `all', search all other buffers, except the ignored ones.  If t, search
+buffers with the same major mode.  If `code', search all buffers with major
+modes in `company-dabbrev-code-modes', or derived from one of them.  See
+also `company-dabbrev-code-time-limit'."
+  :type '(choice (const :tag "Off" nil)
+                 (const :tag "Same major mode" t)
+                 (const :tag "Code major modes" code)
+                 (const :tag "All" all)))
+
+(defcustom company-dabbrev-code-time-limit .1
+  "Determines how long `company-dabbrev-code' should look for matches."
+  :type '(choice (const :tag "Off" nil)
+                 (number :tag "Seconds")))
+
+(defcustom company-dabbrev-code-everywhere nil
+  "Non-nil to offer completions in comments and strings."
+  :type 'boolean)
+
+(defcustom company-dabbrev-code-ignore-case nil
+  "Non-nil to ignore case when collecting completion candidates."
+  :type 'boolean)
+
+(defun company-dabbrev-code--make-regexp (prefix)
+  (concat "\\_<" (if (equal prefix "")
+                     "\\([a-zA-Z]\\|\\s_\\)"
+                   (regexp-quote prefix))
+          "\\(\\sw\\|\\s_\\)*\\_>"))
+
+;;;###autoload
+(defun company-dabbrev-code (command &optional arg &rest ignored)
+  "dabbrev-like `company-mode' backend for code.
+The backend looks for all symbols in the current buffer that aren't in
+comments or strings."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-dabbrev-code))
+    (prefix (and (or (eq t company-dabbrev-code-modes)
+                     (apply #'derived-mode-p company-dabbrev-code-modes))
+                 (or company-dabbrev-code-everywhere
+                     (not (company-in-string-or-comment)))
+                 (or (company-grab-symbol) 'stop)))
+    (candidates (let ((case-fold-search company-dabbrev-code-ignore-case))
+                  (company-dabbrev--search
+                   (company-dabbrev-code--make-regexp arg)
+                   company-dabbrev-code-time-limit
+                   (pcase company-dabbrev-code-other-buffers
+                     (`t (list major-mode))
+                     (`code company-dabbrev-code-modes)
+                     (`all `all))
+                   (not company-dabbrev-code-everywhere))))
+    (ignore-case company-dabbrev-code-ignore-case)
+    (duplicates t)))
+
+(provide 'company-dabbrev-code)
+;;; company-dabbrev-code.el ends here

.emacs.d/elpa/company-20171122.716/company-dabbrev.el

@@ -0,0 +1,198 @@
+;;; company-dabbrev.el --- dabbrev-like company-mode completion backend  -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009, 2011, 2014, 2015, 2016  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defgroup company-dabbrev nil
+  "dabbrev-like completion backend."
+  :group 'company)
+
+(defcustom company-dabbrev-other-buffers 'all
+  "Determines whether `company-dabbrev' should search other buffers.
+If `all', search all other buffers, except the ignored ones.  If t, search
+buffers with the same major mode.  See also `company-dabbrev-time-limit'."
+  :type '(choice (const :tag "Off" nil)
+                 (const :tag "Same major mode" t)
+                 (const :tag "All" all)))
+
+(defcustom company-dabbrev-ignore-buffers "\\`[ *]"
+  "Regexp matching the names of buffers to ignore.
+Or a function that returns non-nil for such buffers."
+  :type '(choice (regexp :tag "Regexp")
+                 (function :tag "Predicate"))
+  :package-version '(company . "0.9.0"))
+
+(defcustom company-dabbrev-time-limit .1
+  "Determines how many seconds `company-dabbrev' should look for matches."
+  :type '(choice (const :tag "Off" nil)
+                 (number :tag "Seconds")))
+
+(defcustom company-dabbrev-char-regexp "\\sw"
+  "A regular expression matching the characters `company-dabbrev' looks for."
+  :type 'regexp)
+
+(defcustom company-dabbrev-ignore-case 'keep-prefix
+  "Non-nil to ignore case when collecting completion candidates.
+When it's `keep-prefix', the text before point will remain unchanged after
+candidate is inserted, even some of its characters have different case.")
+
+(defcustom company-dabbrev-downcase 'case-replace
+  "Whether to downcase the returned candidates.
+
+The value of nil means keep them as-is.
+`case-replace' means use the value of `case-replace'.
+Any other value means downcase.
+
+If you set this value to nil, you may also want to set
+`company-dabbrev-ignore-case' to any value other than `keep-prefix'.")
+
+(defcustom company-dabbrev-minimum-length 4
+  "The minimum length for the completion candidate to be included.
+This variable affects both `company-dabbrev' and `company-dabbrev-code'."
+  :type 'integer
+  :package-version '(company . "0.8.3"))
+
+(defcustom company-dabbrev-ignore-invisible nil
+  "Non-nil to skip invisible text."
+  :type 'boolean
+  :package-version '(company . "0.9.0"))
+
+(defmacro company-dabbrev--time-limit-while (test start limit freq &rest body)
+  (declare (indent 3) (debug t))
+  `(let ((company-time-limit-while-counter 0))
+     (catch 'done
+       (while ,test
+         ,@body
+         (and ,limit
+              (= (cl-incf company-time-limit-while-counter) ,freq)
+              (setq company-time-limit-while-counter 0)
+              (> (float-time (time-since ,start)) ,limit)
+              (throw 'done 'company-time-out))))))
+
+(defun company-dabbrev--make-regexp ()
+  (concat "\\(?:" company-dabbrev-char-regexp "\\)+"))
+
+(defun company-dabbrev--search-buffer (regexp pos symbols start limit
+                                       ignore-comments)
+  (save-excursion
+    (cl-labels ((maybe-collect-match
+                 ()
+                 (let ((match (match-string-no-properties 0)))
+                   (when (and (>= (length match) company-dabbrev-minimum-length)
+                              (not (and company-dabbrev-ignore-invisible
+                                        (invisible-p (match-beginning 0)))))
+                     (push match symbols)))))
+      (goto-char (if pos (1- pos) (point-min)))
+      ;; Search before pos.
+      (let ((tmp-end (point)))
+        (company-dabbrev--time-limit-while (and (not (input-pending-p))
+                                                (> tmp-end (point-min)))
+            start limit 1
+          (ignore-errors
+            (forward-char -10000))
+          (forward-line 0)
+          (save-excursion
+            ;; Before, we used backward search, but it matches non-greedily, and
+            ;; that forced us to use the "beginning/end of word" anchors in
+            ;; `company-dabbrev--make-regexp'.  It's also about 2x slower.
+            (while (and (not (input-pending-p))
+                        (re-search-forward regexp tmp-end t))
+              (if (and ignore-comments (save-match-data (company-in-string-or-comment)))
+                  (re-search-forward "\\s>\\|\\s!\\|\\s\"" tmp-end t)
+                (maybe-collect-match))))
+          (setq tmp-end (point))))
+      (goto-char (or pos (point-min)))
+      ;; Search after pos.
+      (company-dabbrev--time-limit-while (and (not (input-pending-p))
+                                              (re-search-forward regexp nil t))
+          start limit 25
+        (if (and ignore-comments (save-match-data (company-in-string-or-comment)))
+            (re-search-forward "\\s>\\|\\s!\\|\\s\"" nil t)
+          (maybe-collect-match)))
+      symbols)))
+
+(defun company-dabbrev--search (regexp &optional limit other-buffer-modes
+                                ignore-comments)
+  (let* ((start (current-time))
+         (symbols (company-dabbrev--search-buffer regexp (point) nil start limit
+                                                  ignore-comments)))
+    (when other-buffer-modes
+      (cl-dolist (buffer (delq (current-buffer) (buffer-list)))
+        (unless (if (stringp company-dabbrev-ignore-buffers)
+                    (string-match-p company-dabbrev-ignore-buffers
+                                    (buffer-name buffer))
+                  (funcall company-dabbrev-ignore-buffers buffer))
+          (with-current-buffer buffer
+            (when (or (eq other-buffer-modes 'all)
+                      (apply #'derived-mode-p other-buffer-modes))
+              (setq symbols
+                    (company-dabbrev--search-buffer regexp nil symbols start
+                                                    limit ignore-comments)))))
+        (and limit
+             (> (float-time (time-since start)) limit)
+             (cl-return))))
+    symbols))
+
+(defun company-dabbrev--prefix ()
+  ;; Not in the middle of a word.
+  (unless (looking-at company-dabbrev-char-regexp)
+    ;; Emacs can't do greedy backward-search.
+    (company-grab-line (format "\\(?:^\\| \\)[^ ]*?\\(\\(?:%s\\)*\\)"
+                               company-dabbrev-char-regexp)
+                       1)))
+
+(defun company-dabbrev--filter (prefix candidates)
+  (let ((completion-ignore-case company-dabbrev-ignore-case))
+    (all-completions prefix candidates)))
+
+;;;###autoload
+(defun company-dabbrev (command &optional arg &rest ignored)
+  "dabbrev-like `company-mode' completion backend."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-dabbrev))
+    (prefix (company-dabbrev--prefix))
+    (candidates
+     (let* ((case-fold-search company-dabbrev-ignore-case)
+            (words (company-dabbrev--search (company-dabbrev--make-regexp)
+                                            company-dabbrev-time-limit
+                                            (pcase company-dabbrev-other-buffers
+                                              (`t (list major-mode))
+                                              (`all `all))))
+            (downcase-p (if (eq company-dabbrev-downcase 'case-replace)
+                            case-replace
+                          company-dabbrev-downcase)))
+       (setq words (company-dabbrev--filter arg words))
+       (if downcase-p
+           (mapcar 'downcase words)
+         words)))
+    (ignore-case company-dabbrev-ignore-case)
+    (duplicates t)))
+
+(provide 'company-dabbrev)
+;;; company-dabbrev.el ends here

.emacs.d/elpa/company-20171122.716/company-eclim.el

@@ -0,0 +1,186 @@
+;;; company-eclim.el --- company-mode completion backend for Eclim
+
+;; Copyright (C) 2009, 2011, 2013, 2015  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+;;
+;; Using `emacs-eclim' together with (or instead of) this backend is
+;; recommended, as it allows you to use other Eclim features.
+;;
+;; The alternative backend provided by `emacs-eclim' uses `yasnippet'
+;; instead of `company-template' to expand function calls, and it supports
+;; some languages other than Java.
+
+;;; Code:
+
+(require 'company)
+(require 'company-template)
+(require 'cl-lib)
+
+(defgroup company-eclim nil
+  "Completion backend for Eclim."
+  :group 'company)
+
+(defun company-eclim-executable-find ()
+  (let (file)
+    (cl-dolist (eclipse-root '("/Applications/eclipse" "/usr/lib/eclipse"
+                            "/usr/local/lib/eclipse"))
+      (and (file-exists-p (setq file (expand-file-name "plugins" eclipse-root)))
+           (setq file (car (last (directory-files file t "^org.eclim_"))))
+           (file-exists-p (setq file (expand-file-name "bin/eclim" file)))
+           (cl-return file)))))
+
+(defcustom company-eclim-executable
+  (or (bound-and-true-p eclim-executable)
+      (executable-find "eclim")
+      (company-eclim-executable-find))
+  "Location of eclim executable."
+  :type 'file)
+
+(defcustom company-eclim-auto-save t
+  "Determines whether to save the buffer when retrieving completions.
+eclim can only complete correctly when the buffer has been saved."
+  :type '(choice (const :tag "Off" nil)
+                 (const :tag "On" t)))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defvar-local company-eclim--project-dir 'unknown)
+
+(defvar-local company-eclim--project-name nil)
+
+(declare-function json-read "json")
+(defvar json-array-type)
+
+(defun company-eclim--call-process (&rest args)
+  (let ((coding-system-for-read 'utf-8)
+        res)
+    (require 'json)
+    (with-temp-buffer
+      (if (= 0 (setq res (apply 'call-process company-eclim-executable nil t nil
+                                "-command" args)))
+          (let ((json-array-type 'list))
+            (goto-char (point-min))
+            (unless (eobp)
+              (json-read)))
+        (message "Company-eclim command failed with error %d:\n%s" res
+                 (buffer-substring (point-min) (point-max)))
+        nil))))
+
+(defun company-eclim--project-list ()
+  (company-eclim--call-process "project_list"))
+
+(defun company-eclim--project-dir ()
+  (if (eq company-eclim--project-dir 'unknown)
+      (let ((dir (locate-dominating-file buffer-file-name ".project")))
+        (when dir
+          (setq company-eclim--project-dir
+                (directory-file-name
+                 (expand-file-name dir)))))
+    company-eclim--project-dir))
+
+(defun company-eclim--project-name ()
+  (or company-eclim--project-name
+      (let ((dir (company-eclim--project-dir)))
+        (when dir
+          (setq company-eclim--project-name
+                (cl-loop for project in (company-eclim--project-list)
+                         when (equal (cdr (assoc 'path project)) dir)
+                         return (cdr (assoc 'name project))))))))
+
+(defun company-eclim--candidates (prefix)
+  (interactive "d")
+  (let ((project-file (file-relative-name buffer-file-name
+                                          (company-eclim--project-dir)))
+        completions)
+    (when company-eclim-auto-save
+      (when (buffer-modified-p)
+        (basic-save-buffer))
+      ;; FIXME: Sometimes this isn't finished when we complete.
+      (company-eclim--call-process "java_src_update"
+                                   "-p" (company-eclim--project-name)
+                                   "-f" project-file))
+    (dolist (item (cdr (assoc 'completions
+                              (company-eclim--call-process
+                               "java_complete" "-p" (company-eclim--project-name)
+                               "-f" project-file
+                               "-o" (number-to-string
+                                     (company-eclim--search-point prefix))
+                               "-e" "utf-8"
+                               "-l" "standard"))))
+      (let* ((meta (cdr (assoc 'info item)))
+             (completion meta))
+        (when (string-match " ?[(:-]" completion)
+          (setq completion (substring completion 0 (match-beginning 0))))
+        (put-text-property 0 1 'meta meta completion)
+        (push completion completions)))
+    (let ((completion-ignore-case nil))
+      (all-completions prefix completions))))
+
+(defun company-eclim--search-point (prefix)
+  (if (or (cl-plusp (length prefix)) (eq (char-before) ?.))
+      (1- (point))
+    (point)))
+
+(defun company-eclim--meta (candidate)
+  (get-text-property 0 'meta candidate))
+
+(defun company-eclim--annotation (candidate)
+  (let ((meta (company-eclim--meta candidate)))
+    (when (string-match "\\(([^-]*\\) -" meta)
+      (substring meta (match-beginning 1) (match-end 1)))))
+
+(defun company-eclim--prefix ()
+  (let ((prefix (company-grab-symbol)))
+    (when prefix
+      ;; Completion candidates for annotations don't include '@'.
+      (when (eq ?@ (string-to-char prefix))
+        (setq prefix (substring prefix 1)))
+      prefix)))
+
+(defun company-eclim (command &optional arg &rest ignored)
+  "`company-mode' completion backend for Eclim.
+Eclim provides access to Eclipse Java IDE features for other editors.
+
+Eclim version 1.7.13 or newer (?) is required.
+
+Completions only work correctly when the buffer has been saved.
+`company-eclim-auto-save' determines whether to do this automatically."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-eclim))
+    (prefix (and (derived-mode-p 'java-mode 'jde-mode)
+                 buffer-file-name
+                 company-eclim-executable
+                 (company-eclim--project-name)
+                 (not (company-in-string-or-comment))
+                 (or (company-eclim--prefix) 'stop)))
+    (candidates (company-eclim--candidates arg))
+    (meta (company-eclim--meta arg))
+    ;; because "" doesn't return everything
+    (no-cache (equal arg ""))
+    (annotation (company-eclim--annotation arg))
+    (post-completion (let ((anno (company-eclim--annotation arg)))
+                       (when anno
+                         (insert anno)
+                         (company-template-c-like-templatify anno))))))
+
+(provide 'company-eclim)
+;;; company-eclim.el ends here

.emacs.d/elpa/company-20171122.716/company-elisp.el

@@ -0,0 +1,225 @@
+;;; company-elisp.el --- company-mode completion backend for Emacs Lisp -*- lexical-binding: t -*-
+
+;; Copyright (C) 2009, 2011-2013  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'help-mode)
+(require 'find-func)
+
+(defgroup company-elisp nil
+  "Completion backend for Emacs Lisp."
+  :group 'company)
+
+(defcustom company-elisp-detect-function-context t
+  "If enabled, offer Lisp functions only in appropriate contexts.
+Functions are offered for completion only after ' and \(."
+  :type '(choice (const :tag "Off" nil)
+                 (const :tag "On" t)))
+
+(defcustom company-elisp-show-locals-first t
+  "If enabled, locally bound variables and functions are displayed
+first in the candidates list."
+  :type '(choice (const :tag "Off" nil)
+                 (const :tag "On" t)))
+
+(defun company-elisp--prefix ()
+  (let ((prefix (company-grab-symbol)))
+    (if prefix
+        (when (if (company-in-string-or-comment)
+                  (= (char-before (- (point) (length prefix))) ?`)
+                (company-elisp--should-complete))
+          prefix)
+      'stop)))
+
+(defun company-elisp--predicate (symbol)
+  (or (boundp symbol)
+      (fboundp symbol)
+      (facep symbol)
+      (featurep symbol)))
+
+(defun company-elisp--fns-regexp (&rest names)
+  (concat "\\_<\\(?:cl-\\)?" (regexp-opt names) "\\*?\\_>"))
+
+(defvar company-elisp-parse-limit 30)
+(defvar company-elisp-parse-depth 100)
+
+(defvar company-elisp-defun-names '("defun" "defmacro" "defsubst"))
+
+(defvar company-elisp-var-binding-regexp
+  (apply #'company-elisp--fns-regexp "let" "lambda" "lexical-let"
+         company-elisp-defun-names)
+  "Regular expression matching head of a multiple variable bindings form.")
+
+(defvar company-elisp-var-binding-regexp-1
+  (company-elisp--fns-regexp "dolist" "dotimes")
+  "Regular expression matching head of a form with one variable binding.")
+
+(defvar company-elisp-fun-binding-regexp
+  (company-elisp--fns-regexp "flet" "labels")
+  "Regular expression matching head of a function bindings form.")
+
+(defvar company-elisp-defuns-regexp
+  (concat "([ \t\n]*"
+          (apply #'company-elisp--fns-regexp company-elisp-defun-names)))
+
+(defun company-elisp--should-complete ()
+  (let ((start (point))
+        (depth (car (syntax-ppss))))
+    (not
+     (when (> depth 0)
+       (save-excursion
+         (up-list (- depth))
+         (when (looking-at company-elisp-defuns-regexp)
+           (forward-char)
+           (forward-sexp 1)
+           (unless (= (point) start)
+             (condition-case nil
+                 (let ((args-end (scan-sexps (point) 2)))
+                   (or (null args-end)
+                       (> args-end start)))
+               (scan-error
+                t)))))))))
+
+(defun company-elisp--locals (prefix functions-p)
+  (let ((regexp (concat "[ \t\n]*\\(\\_<" (regexp-quote prefix)
+                        "\\(?:\\sw\\|\\s_\\)*\\_>\\)"))
+        (pos (point))
+        res)
+    (condition-case nil
+        (save-excursion
+          (dotimes (_ company-elisp-parse-depth)
+            (up-list -1)
+            (save-excursion
+              (when (eq (char-after) ?\()
+                (forward-char 1)
+                (when (ignore-errors
+                        (save-excursion (forward-list)
+                                        (<= (point) pos)))
+                  (skip-chars-forward " \t\n")
+                  (cond
+                   ((looking-at (if functions-p
+                                    company-elisp-fun-binding-regexp
+                                  company-elisp-var-binding-regexp))
+                    (down-list 1)
+                    (condition-case nil
+                        (dotimes (_ company-elisp-parse-limit)
+                          (save-excursion
+                            (when (looking-at "[ \t\n]*(")
+                              (down-list 1))
+                            (when (looking-at regexp)
+                              (cl-pushnew (match-string-no-properties 1) res)))
+                          (forward-sexp))
+                      (scan-error nil)))
+                   ((unless functions-p
+                      (looking-at company-elisp-var-binding-regexp-1))
+                    (down-list 1)
+                    (when (looking-at regexp)
+                      (cl-pushnew (match-string-no-properties 1) res)))))))))
+      (scan-error nil))
+    res))
+
+(defun company-elisp-candidates (prefix)
+  (let* ((predicate (company-elisp--candidates-predicate prefix))
+         (locals (company-elisp--locals prefix (eq predicate 'fboundp)))
+         (globals (company-elisp--globals prefix predicate))
+         (locals (cl-loop for local in locals
+                          when (not (member local globals))
+                          collect local)))
+    (if company-elisp-show-locals-first
+        (append (sort locals 'string<)
+                (sort globals 'string<))
+      (append locals globals))))
+
+(defun company-elisp--globals (prefix predicate)
+  (all-completions prefix obarray predicate))
+
+(defun company-elisp--candidates-predicate (prefix)
+  (let* ((completion-ignore-case nil)
+         (beg (- (point) (length prefix)))
+         (before (char-before beg)))
+    (if (and company-elisp-detect-function-context
+             (not (memq before '(?' ?`))))
+        (if (and (eq before ?\()
+                 (not
+                  (save-excursion
+                    (ignore-errors
+                      (goto-char (1- beg))
+                      (or (company-elisp--before-binding-varlist-p)
+                          (progn
+                            (up-list -1)
+                            (company-elisp--before-binding-varlist-p)))))))
+            'fboundp
+          'boundp)
+      'company-elisp--predicate)))
+
+(defun company-elisp--before-binding-varlist-p ()
+  (save-excursion
+    (and (prog1 (search-backward "(")
+           (forward-char 1))
+         (looking-at company-elisp-var-binding-regexp))))
+
+(defun company-elisp--doc (symbol)
+  (let* ((symbol (intern symbol))
+         (doc (if (fboundp symbol)
+                  (documentation symbol t)
+                (documentation-property symbol 'variable-documentation t))))
+    (and (stringp doc)
+         (string-match ".*$" doc)
+         (match-string 0 doc))))
+
+;;;###autoload
+(defun company-elisp (command &optional arg &rest ignored)
+  "`company-mode' completion backend for Emacs Lisp."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-elisp))
+    (prefix (and (derived-mode-p 'emacs-lisp-mode 'inferior-emacs-lisp-mode)
+                 (company-elisp--prefix)))
+    (candidates (company-elisp-candidates arg))
+    (sorted company-elisp-show-locals-first)
+    (meta (company-elisp--doc arg))
+    (doc-buffer (let ((symbol (intern arg)))
+                  (save-window-excursion
+                    (ignore-errors
+                      (cond
+                       ((fboundp symbol) (describe-function symbol))
+                       ((boundp symbol) (describe-variable symbol))
+                       ((featurep symbol) (describe-package symbol))
+                       ((facep symbol) (describe-face symbol))
+                       (t (signal 'user-error nil)))
+                      (help-buffer)))))
+    (location (let ((sym (intern arg)))
+                (cond
+                 ((fboundp sym) (find-definition-noselect sym nil))
+                 ((boundp sym) (find-definition-noselect sym 'defvar))
+                 ((featurep sym) (cons (find-file-noselect (find-library-name
+                                                            (symbol-name sym)))
+                                       0))
+                 ((facep sym) (find-definition-noselect sym 'defface)))))))
+
+(provide 'company-elisp)
+;;; company-elisp.el ends here

.emacs.d/elpa/company-20171122.716/company-etags.el

@@ -0,0 +1,107 @@
+;;; company-etags.el --- company-mode completion backend for etags
+
+;; Copyright (C) 2009-2011, 2014  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'etags)
+
+(defgroup company-etags nil
+  "Completion backend for etags."
+  :group 'company)
+
+(defcustom company-etags-use-main-table-list t
+  "Always search `tags-table-list' if set.
+If this is disabled, `company-etags' will try to find the one table for each
+buffer automatically."
+  :type '(choice (const :tag "off" nil)
+                 (const :tag "on" t)))
+
+(defcustom company-etags-ignore-case nil
+  "Non-nil to ignore case in completion candidates."
+  :type 'boolean
+  :package-version '(company . "0.7.3"))
+
+(defcustom company-etags-everywhere nil
+  "Non-nil to offer completions in comments and strings.
+Set it to t or to a list of major modes."
+  :type '(choice (const :tag "Off" nil)
+                 (const :tag "Any supported mode" t)
+                 (repeat :tag "Some major modes"
+                         (symbol :tag "Major mode")))
+  :package-version '(company . "0.9.0"))
+
+(defvar company-etags-modes '(prog-mode c-mode objc-mode c++-mode java-mode
+                              jde-mode pascal-mode perl-mode python-mode))
+
+(defvar-local company-etags-buffer-table 'unknown)
+
+(defun company-etags-find-table ()
+  (let ((file (expand-file-name
+               "TAGS"
+               (locate-dominating-file (or buffer-file-name
+                                           default-directory)
+                                       "TAGS"))))
+    (when (and file (file-regular-p file))
+      (list file))))
+
+(defun company-etags-buffer-table ()
+  (or (and company-etags-use-main-table-list tags-table-list)
+      (if (eq company-etags-buffer-table 'unknown)
+          (setq company-etags-buffer-table (company-etags-find-table))
+        company-etags-buffer-table)))
+
+(defun company-etags--candidates (prefix)
+  (let ((tags-table-list (company-etags-buffer-table))
+        (completion-ignore-case company-etags-ignore-case))
+    (and (or tags-file-name tags-table-list)
+         (fboundp 'tags-completion-table)
+         (save-excursion
+           (visit-tags-table-buffer)
+           (all-completions prefix (tags-completion-table))))))
+
+;;;###autoload
+(defun company-etags (command &optional arg &rest ignored)
+  "`company-mode' completion backend for etags."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-etags))
+    (prefix (and (apply #'derived-mode-p company-etags-modes)
+                 (or (eq t company-etags-everywhere)
+                     (apply #'derived-mode-p company-etags-everywhere)
+                     (not (company-in-string-or-comment)))
+                 (company-etags-buffer-table)
+                 (or (company-grab-symbol) 'stop)))
+    (candidates (company-etags--candidates arg))
+    (location (let ((tags-table-list (company-etags-buffer-table)))
+                (when (fboundp 'find-tag-noselect)
+                  (save-excursion
+                    (let ((buffer (find-tag-noselect arg)))
+                      (cons buffer (with-current-buffer buffer (point))))))))
+    (ignore-case company-etags-ignore-case)))
+
+(provide 'company-etags)
+;;; company-etags.el ends here

.emacs.d/elpa/company-20171122.716/company-files.el

@@ -0,0 +1,148 @@
+;;; company-files.el --- company-mode completion backend for file names
+
+;; Copyright (C) 2009-2011, 2014-2015  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(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)
+  ;; Don't use directory-files. It produces directories without trailing /.
+  (condition-case err
+      (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))
+    (file-error nil)))
+
+(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-zA-Z]:/"
+                 "/"))
+         (begin (concat "\\(?:\\.\\{1,2\\}/\\|~/\\|" root "\\)")))
+    (list (concat "\"\\(" begin "[^\"\n]*\\)")
+          (concat "\'\\(" begin "[^\'\n]*\\)")
+          (concat "\\(?:[ \t=]\\|^\\)\\(" begin "[^ \t\n]*\\)"))))
+
+(defun company-files--grab-existing-name ()
+  ;; Grab the file name.
+  ;; When surrounded with quotes, it can include spaces.
+  (let (file dir)
+    (and (cl-dolist (regexp company-files--regexps)
+           (when (setq file (company-grab-line regexp 1))
+             (cl-return file)))
+         (company-files--connected-p file)
+         (setq dir (file-name-directory file))
+         (not (string-match "//" dir))
+         (file-exists-p dir)
+         file)))
+
+(defun company-files--connected-p (file)
+  (or (not (file-remote-p file))
+      (file-remote-p file nil t)))
+
+(defun company-files--trailing-slash-p (file)
+  ;; `file-directory-p' is very expensive on remotes. We are relying on
+  ;; `file-name-all-completions' returning directories with trailing / instead.
+  (let ((len (length file)))
+    (and (> len 0) (eq (aref file (1- len)) ?/))))
+
+(defvar company-files--completion-cache nil)
+
+(defun company-files--complete (prefix)
+  (let* ((dir (file-name-directory prefix))
+         (file (file-name-nondirectory prefix))
+         (key (list file
+                    (expand-file-name dir)
+                    (nth 5 (file-attributes dir))))
+         (completion-ignore-case read-file-name-completion-ignore-case))
+    (unless (company-file--keys-match-p key (car company-files--completion-cache))
+      (let* ((candidates (mapcar (lambda (f) (concat dir f))
+                                 (company-files--directory-files dir file)))
+             (directories (unless (file-remote-p dir)
+                            (cl-remove-if-not (lambda (f)
+                                                (and (company-files--trailing-slash-p f)
+                                                     (not (file-remote-p f))
+                                                     (company-files--connected-p f)))
+                                              candidates)))
+             (children (and directories
+                            (cl-mapcan (lambda (d)
+                                         (mapcar (lambda (c) (concat d c))
+                                                 (company-files--directory-files d "")))
+                                       directories))))
+        (setq company-files--completion-cache
+              (cons key (append candidates children)))))
+    (all-completions prefix
+                     (cdr company-files--completion-cache))))
+
+(defun company-file--keys-match-p (new old)
+  (and (equal (cdr old) (cdr new))
+       (string-prefix-p (car old) (car new))))
+
+;;;###autoload
+(defun company-files (command &optional arg &rest ignored)
+  "`company-mode' completion backend existing file names.
+Completions works for proper absolute and relative files paths.
+File paths with spaces are only supported inside strings."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-files))
+    (prefix (company-files--grab-existing-name))
+    (candidates (company-files--complete arg))
+    (location (cons (dired-noselect
+                     (file-name-directory (directory-file-name arg))) 1))
+    (post-completion (when (company-files--trailing-slash-p arg)
+                       (delete-char -1)))
+    (sorted t)
+    (no-cache t)))
+
+(provide 'company-files)
+;;; company-files.el ends here

.emacs.d/elpa/company-20171122.716/company-gtags.el

@@ -0,0 +1,117 @@
+;;; company-gtags.el --- company-mode completion backend for GNU Global
+
+;; Copyright (C) 2009-2011, 2014  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'company-template)
+(require 'cl-lib)
+
+(defgroup company-gtags nil
+  "Completion backend for GNU Global."
+  :group 'company)
+
+(defcustom company-gtags-executable
+  (executable-find "global")
+  "Location of GNU global executable."
+  :type 'string)
+
+(define-obsolete-variable-alias
+  'company-gtags-gnu-global-program-name
+  'company-gtags-executable "earlier")
+
+(defcustom company-gtags-insert-arguments t
+  "When non-nil, insert function arguments as a template after completion."
+  :type 'boolean
+  :package-version '(company . "0.8.1"))
+
+(defvar-local company-gtags--tags-available-p 'unknown)
+
+(defcustom company-gtags-modes '(prog-mode jde-mode)
+  "Modes that use `company-gtags'.
+In all these modes (and their derivatives) `company-gtags' will perform
+completion."
+  :type '(repeat (symbol :tag "Major mode"))
+  :package-version '(company . "0.8.4"))
+
+(defun company-gtags--tags-available-p ()
+  (if (eq company-gtags--tags-available-p 'unknown)
+      (setq company-gtags--tags-available-p
+            (locate-dominating-file buffer-file-name "GTAGS"))
+    company-gtags--tags-available-p))
+
+(defun company-gtags--fetch-tags (prefix)
+  (with-temp-buffer
+    (let (tags)
+      (when (= 0 (process-file company-gtags-executable nil
+                               ;; "-T" goes through all the tag files listed in GTAGSLIBPATH
+                               (list (current-buffer) nil) nil "-xGqT" (concat "^" prefix)))
+        (goto-char (point-min))
+        (cl-loop while
+                 (re-search-forward (concat
+                                     "^"
+                                     "\\([^ ]*\\)" ;; completion
+                                     "[ \t]+\\([[:digit:]]+\\)" ;; linum
+                                     "[ \t]+\\([^ \t]+\\)" ;; file
+                                     "[ \t]+\\(.*\\)" ;; definition
+                                     "$"
+                                     ) nil t)
+                 collect
+                 (propertize (match-string 1)
+                             'meta (match-string 4)
+                             'location (cons (expand-file-name (match-string 3))
+                                             (string-to-number (match-string 2)))
+                             ))))))
+
+(defun company-gtags--annotation (arg)
+  (let ((meta (get-text-property 0 'meta arg)))
+    (when (string-match (concat arg "\\((.*)\\).*") meta)
+      (match-string 1 meta))))
+
+;;;###autoload
+(defun company-gtags (command &optional arg &rest ignored)
+  "`company-mode' completion backend for GNU Global."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-gtags))
+    (prefix (and company-gtags-executable
+                 buffer-file-name
+                 (apply #'derived-mode-p company-gtags-modes)
+                 (not (company-in-string-or-comment))
+                 (company-gtags--tags-available-p)
+                 (or (company-grab-symbol) 'stop)))
+    (candidates (company-gtags--fetch-tags arg))
+    (sorted t)
+    (duplicates t)
+    (annotation (company-gtags--annotation arg))
+    (meta (get-text-property 0 'meta arg))
+    (location (get-text-property 0 'location arg))
+    (post-completion (let ((anno (company-gtags--annotation arg)))
+                       (when (and company-gtags-insert-arguments anno)
+                         (insert anno)
+                         (company-template-c-like-templatify anno))))))
+
+(provide 'company-gtags)
+;;; company-gtags.el ends here

.emacs.d/elpa/company-20171122.716/company-ispell.el

@@ -0,0 +1,82 @@
+;;; company-ispell.el --- company-mode completion backend using Ispell
+
+;; Copyright (C) 2009-2011, 2013-2016  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'ispell)
+
+(defgroup company-ispell nil
+  "Completion backend using Ispell."
+  :group 'company)
+
+(defcustom company-ispell-dictionary nil
+  "Dictionary to use for `company-ispell'.
+If nil, use `ispell-complete-word-dict'."
+  :type '(choice (const :tag "default (nil)" nil)
+                 (file :tag "dictionary" t)))
+
+(defvar company-ispell-available 'unknown)
+
+(defalias 'company-ispell--lookup-words
+  (if (fboundp 'ispell-lookup-words)
+      'ispell-lookup-words
+    'lookup-words))
+
+(defun company-ispell-available ()
+  (when (eq company-ispell-available 'unknown)
+    (condition-case err
+        (progn
+          (company-ispell--lookup-words "WHATEVER")
+          (setq company-ispell-available t))
+      (error
+       (message "Company: ispell-look-command not found")
+       (setq company-ispell-available nil))))
+  company-ispell-available)
+
+;;;###autoload
+(defun company-ispell (command &optional arg &rest ignored)
+  "`company-mode' completion backend using Ispell."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-ispell))
+    (prefix (when (company-ispell-available)
+              (company-grab-word)))
+    (candidates
+     (let ((words (company-ispell--lookup-words
+                   arg
+                   (or company-ispell-dictionary ispell-complete-word-dict)))
+           (completion-ignore-case t))
+       (if (string= arg "")
+           ;; Small optimization.
+           words
+         ;; Work around issue #284.
+         (all-completions arg words))))
+    (sorted t)
+    (ignore-case 'keep-prefix)))
+
+(provide 'company-ispell)
+;;; company-ispell.el ends here

.emacs.d/elpa/company-20171122.716/company-keywords.el

@@ -0,0 +1,268 @@
+;;; company-keywords.el --- A company backend for programming language keywords
+
+;; Copyright (C) 2009-2011, 2016  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defun company-keywords-upper-lower (&rest lst)
+  ;; Upcase order is different for _.
+  (nconc (sort (mapcar 'upcase lst) 'string<) lst))
+
+(defvar company-keywords-alist
+  ;; Please contribute corrections or additions.
+  `((c++-mode
+     "alignas" "alignof" "asm" "auto" "bool" "break" "case" "catch" "char"
+     "char16_t" "char32_t" "class" "const" "const_cast" "constexpr" "continue"
+     "decltype" "default" "delete" "do" "double" "dynamic_cast" "else" "enum"
+     "explicit" "export" "extern" "false" "final" "float" "for" "friend"
+     "goto" "if" "inline" "int" "long" "mutable" "namespace" "new" "noexcept"
+     "nullptr" "operator" "override"
+     "private" "protected" "public" "register" "reinterpret_cast"
+     "return" "short" "signed" "sizeof" "static" "static_assert"
+     "static_cast" "struct" "switch" "template" "this" "thread_local"
+     "throw" "true" "try" "typedef" "typeid" "typename"
+     "union" "unsigned" "using" "virtual" "void" "volatile" "wchar_t" "while")
+    (c-mode
+     "auto" "break" "case" "char" "const" "continue" "default" "do"
+     "double" "else" "enum" "extern" "float" "for" "goto" "if" "int" "long"
+     "register" "return" "short" "signed" "sizeof" "static" "struct"
+     "switch" "typedef" "union" "unsigned" "void" "volatile" "while")
+    (csharp-mode
+     "abstract" "add" "alias" "as" "base" "bool" "break" "byte" "case"
+     "catch" "char" "checked" "class" "const" "continue" "decimal" "default"
+     "delegate" "do" "double" "else" "enum" "event" "explicit" "extern"
+     "false" "finally" "fixed" "float" "for" "foreach" "get" "global" "goto"
+     "if" "implicit" "in" "int" "interface" "internal" "is" "lock" "long"
+     "namespace" "new" "null" "object" "operator" "out" "override" "params"
+     "partial" "private" "protected" "public" "readonly" "ref" "remove"
+     "return" "sbyte" "sealed" "set" "short" "sizeof" "stackalloc" "static"
+     "string" "struct" "switch" "this" "throw" "true" "try" "typeof" "uint"
+     "ulong" "unchecked" "unsafe" "ushort" "using" "value" "var" "virtual"
+     "void" "volatile" "where" "while" "yield")
+    (d-mode
+     ;; from http://www.digitalmars.com/d/2.0/lex.html
+     "abstract" "alias" "align" "asm"
+     "assert" "auto" "body" "bool" "break" "byte" "case" "cast" "catch"
+     "cdouble" "cent" "cfloat" "char" "class" "const" "continue" "creal"
+     "dchar" "debug" "default" "delegate" "delete" "deprecated" "do"
+     "double" "else" "enum" "export" "extern" "false" "final" "finally"
+     "float" "for" "foreach" "foreach_reverse" "function" "goto" "idouble"
+     "if" "ifloat" "import" "in" "inout" "int" "interface" "invariant"
+     "ireal" "is" "lazy" "long" "macro" "mixin" "module" "new" "nothrow"
+     "null" "out" "override" "package" "pragma" "private" "protected"
+     "public" "pure" "real" "ref" "return" "scope" "short" "static" "struct"
+     "super" "switch" "synchronized" "template" "this" "throw" "true" "try"
+     "typedef" "typeid" "typeof" "ubyte" "ucent" "uint" "ulong" "union"
+     "unittest" "ushort" "version" "void" "volatile" "wchar" "while" "with")
+    (f90-mode .
+     ;; from f90.el
+     ;; ".AND." ".GE." ".GT." ".LT." ".LE." ".NE." ".OR." ".TRUE." ".FALSE."
+     ,(company-keywords-upper-lower
+      "abs" "abstract" "achar" "acos" "adjustl" "adjustr" "aimag" "aint"
+      "align" "all" "all_prefix" "all_scatter" "all_suffix" "allocatable"
+      "allocate" "allocated" "and" "anint" "any" "any_prefix" "any_scatter"
+      "any_suffix" "asin" "assign" "assignment" "associate" "associated"
+      "asynchronous" "atan" "atan2" "backspace" "bind" "bit_size" "block"
+      "btest" "c_alert" "c_associated" "c_backspace" "c_bool"
+      "c_carriage_return" "c_char" "c_double" "c_double_complex" "c_f_pointer"
+      "c_f_procpointer" "c_float" "c_float_complex" "c_form_feed" "c_funloc"
+      "c_funptr" "c_horizontal_tab" "c_int" "c_int16_t" "c_int32_t" "c_int64_t"
+      "c_int8_t" "c_int_fast16_t" "c_int_fast32_t" "c_int_fast64_t"
+      "c_int_fast8_t" "c_int_least16_t" "c_int_least32_t" "c_int_least64_t"
+      "c_int_least8_t" "c_intmax_t" "c_intptr_t" "c_loc" "c_long"
+      "c_long_double" "c_long_double_complex" "c_long_long" "c_new_line"
+      "c_null_char" "c_null_funptr" "c_null_ptr" "c_ptr" "c_short"
+      "c_signed_char" "c_size_t" "c_vertical_tab" "call" "case" "ceiling"
+      "char" "character" "character_storage_size" "class" "close" "cmplx"
+      "command_argument_count" "common" "complex" "conjg" "contains" "continue"
+      "copy_prefix" "copy_scatter" "copy_suffix" "cos" "cosh" "count"
+      "count_prefix" "count_scatter" "count_suffix" "cpu_time" "cshift"
+      "cycle" "cyclic" "data" "date_and_time" "dble" "deallocate" "deferred"
+      "digits" "dim" "dimension" "distribute" "do" "dot_product" "double"
+      "dprod" "dynamic" "elemental" "else" "elseif" "elsewhere" "end" "enddo"
+      "endfile" "endif" "entry" "enum" "enumerator" "eoshift" "epsilon" "eq"
+      "equivalence" "eqv" "error_unit" "exit" "exp" "exponent" "extends"
+      "extends_type_of" "external" "extrinsic" "false" "file_storage_size"
+      "final" "floor" "flush" "forall" "format" "fraction" "function" "ge"
+      "generic" "get_command" "get_command_argument" "get_environment_variable"
+      "goto" "grade_down" "grade_up" "gt" "hpf_alignment" "hpf_distribution"
+      "hpf_template" "huge" "iachar" "iall" "iall_prefix" "iall_scatter"
+      "iall_suffix" "iand" "iany" "iany_prefix" "iany_scatter" "iany_suffix"
+      "ibclr" "ibits" "ibset" "ichar" "ieee_arithmetic" "ieee_exceptions"
+      "ieee_features" "ieee_get_underflow_mode" "ieee_set_underflow_mode"
+      "ieee_support_underflow_control" "ieor" "if" "ilen" "implicit"
+      "import" "include" "independent" "index" "inherit" "input_unit"
+      "inquire" "int" "integer" "intent" "interface" "intrinsic" "ior"
+      "iostat_end" "iostat_eor" "iparity" "iparity_prefix" "iparity_scatter"
+      "iparity_suffix" "ishft" "ishftc" "iso_c_binding" "iso_fortran_env"
+      "kind" "lbound" "le" "leadz" "len" "len_trim" "lge" "lgt" "lle" "llt"
+      "log" "log10" "logical" "lt" "matmul" "max" "maxexponent" "maxloc"
+      "maxval" "maxval_prefix" "maxval_scatter" "maxval_suffix" "merge"
+      "min" "minexponent" "minloc" "minval" "minval_prefix" "minval_scatter"
+      "minval_suffix" "mod" "module" "modulo" "move_alloc" "mvbits" "namelist"
+      "ne" "nearest" "neqv" "new" "new_line" "nint" "non_intrinsic"
+      "non_overridable" "none" "nopass" "not" "null" "nullify"
+      "number_of_processors" "numeric_storage_size" "only" "onto" "open"
+      "operator" "optional" "or" "output_unit" "pack" "parameter" "parity"
+      "parity_prefix" "parity_scatter" "parity_suffix" "pass" "pause"
+      "pointer" "popcnt" "poppar" "precision" "present" "print" "private"
+      "procedure" "processors" "processors_shape" "product" "product_prefix"
+      "product_scatter" "product_suffix" "program" "protected" "public"
+      "pure" "radix" "random_number" "random_seed" "range" "read" "real"
+      "realign" "recursive" "redistribute" "repeat" "reshape" "result"
+      "return" "rewind" "rrspacing" "same_type_as" "save" "scale" "scan"
+      "select" "selected_char_kind" "selected_int_kind" "selected_real_kind"
+      "sequence" "set_exponent" "shape" "sign" "sin" "sinh" "size" "spacing"
+      "spread" "sqrt" "stop" "subroutine" "sum" "sum_prefix" "sum_scatter"
+      "sum_suffix" "system_clock" "tan" "tanh" "target" "template" "then"
+      "tiny" "transfer" "transpose" "trim" "true" "type" "ubound" "unpack"
+      "use" "value" "verify" "volatile" "wait" "where" "while" "with" "write"))
+    (java-mode
+     "abstract" "assert" "boolean" "break" "byte" "case" "catch" "char" "class"
+     "continue" "default" "do" "double" "else" "enum" "extends" "final"
+     "finally" "float" "for" "if" "implements" "import" "instanceof" "int"
+     "interface" "long" "native" "new" "package" "private" "protected" "public"
+     "return" "short" "static" "strictfp" "super" "switch" "synchronized"
+     "this" "throw" "throws" "transient" "try" "void" "volatile" "while")
+    (javascript-mode
+     "break" "catch" "const" "continue" "delete" "do" "else" "export" "for"
+     "function" "if" "import" "in" "instanceOf" "label" "let" "new" "return"
+     "switch" "this" "throw" "try" "typeof" "var" "void" "while" "with" "yield")
+    (objc-mode
+     "@catch" "@class" "@encode" "@end" "@finally" "@implementation"
+     "@interface" "@private" "@protected" "@protocol" "@public"
+     "@selector" "@synchronized" "@throw" "@try" "alloc" "autorelease"
+     "bycopy" "byref" "in" "inout" "oneway" "out" "release" "retain")
+    (perl-mode
+     ;; from cperl.el
+     "AUTOLOAD" "BEGIN" "CHECK" "CORE" "DESTROY" "END" "INIT" "__END__"
+     "__FILE__" "__LINE__" "abs" "accept" "alarm" "and" "atan2" "bind"
+     "binmode" "bless" "caller" "chdir" "chmod" "chomp" "chop" "chown" "chr"
+     "chroot" "close" "closedir" "cmp" "connect" "continue" "cos"
+     "crypt" "dbmclose" "dbmopen" "defined" "delete" "die" "do" "dump" "each"
+     "else" "elsif" "endgrent" "endhostent" "endnetent" "endprotoent"
+     "endpwent" "endservent" "eof" "eq" "eval" "exec" "exists" "exit" "exp"
+     "fcntl" "fileno" "flock" "for" "foreach" "fork" "format" "formline"
+     "ge" "getc" "getgrent" "getgrgid" "getgrnam" "gethostbyaddr"
+     "gethostbyname" "gethostent" "getlogin" "getnetbyaddr" "getnetbyname"
+     "getnetent" "getpeername" "getpgrp" "getppid" "getpriority"
+     "getprotobyname" "getprotobynumber" "getprotoent" "getpwent" "getpwnam"
+     "getpwuid" "getservbyname" "getservbyport" "getservent" "getsockname"
+     "getsockopt" "glob" "gmtime" "goto" "grep" "gt" "hex" "if" "index" "int"
+     "ioctl" "join" "keys" "kill" "last" "lc" "lcfirst" "le" "length"
+     "link" "listen" "local" "localtime" "lock" "log" "lstat" "lt" "map"
+     "mkdir" "msgctl" "msgget" "msgrcv" "msgsnd" "my" "ne" "next" "no"
+     "not" "oct" "open" "opendir" "or" "ord" "our" "pack" "package" "pipe"
+     "pop" "pos" "print" "printf" "push" "q" "qq" "quotemeta" "qw" "qx"
+     "rand" "read" "readdir" "readline" "readlink" "readpipe" "recv" "redo"
+     "ref" "rename" "require" "reset" "return" "reverse" "rewinddir" "rindex"
+     "rmdir" "scalar" "seek" "seekdir" "select" "semctl" "semget" "semop"
+     "send" "setgrent" "sethostent" "setnetent" "setpgrp" "setpriority"
+     "setprotoent" "setpwent" "setservent" "setsockopt" "shift" "shmctl"
+     "shmget" "shmread" "shmwrite" "shutdown" "sin" "sleep" "socket"
+     "socketpair" "sort" "splice" "split" "sprintf" "sqrt" "srand" "stat"
+     "study" "sub" "substr" "symlink" "syscall" "sysopen" "sysread" "system"
+     "syswrite" "tell" "telldir" "tie" "time" "times" "tr" "truncate" "uc"
+     "ucfirst" "umask" "undef" "unless" "unlink" "unpack" "unshift" "untie"
+     "until" "use" "utime" "values" "vec" "wait" "waitpid"
+     "wantarray" "warn" "while" "write" "x" "xor" "y")
+    (php-mode
+     "__CLASS__" "__DIR__" "__FILE__" "__FUNCTION__" "__LINE__" "__METHOD__"
+     "__NAMESPACE__" "_once" "abstract" "and" "array" "as" "break" "case"
+     "catch" "cfunction" "class" "clone" "const" "continue" "declare"
+     "default" "die" "do" "echo" "else" "elseif" "empty" "enddeclare"
+     "endfor" "endforeach" "endif" "endswitch" "endwhile" "eval" "exception"
+     "exit" "extends" "final" "for" "foreach" "function" "global"
+     "goto" "if" "implements" "include" "instanceof" "interface"
+     "isset" "list" "namespace" "new" "old_function" "or" "php_user_filter"
+     "print" "private" "protected" "public" "require" "require_once" "return"
+     "static" "switch" "this" "throw" "try" "unset" "use" "var" "while" "xor")
+    (python-mode
+     "and" "assert" "break" "class" "continue" "def" "del" "elif" "else"
+     "except" "exec" "finally" "for" "from" "global" "if" "import" "in" "is"
+     "lambda" "not" "or" "pass" "print" "raise" "return" "try" "while" "yield")
+    (ruby-mode
+     "BEGIN" "END" "alias" "and"  "begin" "break" "case" "class" "def" "defined?"
+     "do" "else" "elsif"  "end" "ensure" "false" "for" "if" "in" "module"
+     "next" "nil" "not" "or" "redo" "rescue" "retry" "return" "self" "super"
+     "then" "true" "undef" "unless" "until" "when" "while" "yield")
+    ;; From https://doc.rust-lang.org/grammar.html#keywords
+    ;; but excluding unused reserved words: https://www.reddit.com/r/rust/comments/34fq0k/is_there_a_good_list_of_rusts_keywords/cqucvnj
+    (go-mode
+     "break" "case" "chan" "const" "continue" "default" "defer" "else" "fallthrough"
+     "for" "func" "go" "goto" "if" "import" "interface" "map" "package" "range"
+     "return" "select" "struct" "switch" "type" "var")
+    (rust-mode
+     "Self"
+     "as" "box" "break" "const" "continue" "crate" "else" "enum" "extern"
+     "false" "fn" "for" "if" "impl" "in" "let" "loop" "macro" "match" "mod"
+     "move" "mut" "pub" "ref" "return" "self" "static" "struct" "super"
+     "trait" "true" "type" "unsafe" "use" "where" "while")
+    (scala-mode
+     "abstract" "case" "catch" "class" "def" "do" "else" "extends" "false"
+     "final" "finally" "for" "forSome" "if" "implicit" "import" "lazy" "match"
+     "new" "null" "object" "override" "package" "private" "protected"
+     "return" "sealed" "super" "this" "throw" "trait" "true" "try" "type" "val"
+     "var" "while" "with" "yield")
+    (julia-mode
+     "abstract" "break" "case" "catch" "const" "continue" "do" "else" "elseif"
+     "end" "eval" "export" "false" "finally" "for" "function" "global" "if"
+     "ifelse" "immutable" "import" "importall" "in" "let" "macro" "module"
+     "otherwise" "quote" "return" "switch" "throw" "true" "try" "type"
+     "typealias" "using" "while"
+     )
+    ;; aliases
+    (js2-mode . javascript-mode)
+    (js2-jsx-mode . javascript-mode)
+    (espresso-mode . javascript-mode)
+    (js-mode . javascript-mode)
+    (js-jsx-mode . javascript-mode)
+    (cperl-mode . perl-mode)
+    (jde-mode . java-mode)
+    (ess-julia-mode . julia-mode)
+    (enh-ruby-mode . ruby-mode))
+  "Alist mapping major-modes to sorted keywords for `company-keywords'.")
+
+;;;###autoload
+(defun company-keywords (command &optional arg &rest ignored)
+  "`company-mode' backend for programming language keywords."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-keywords))
+    (prefix (and (assq major-mode company-keywords-alist)
+                 (not (company-in-string-or-comment))
+                 (or (company-grab-symbol) 'stop)))
+    (candidates
+     (let ((completion-ignore-case nil)
+           (symbols (cdr (assq major-mode company-keywords-alist))))
+       (all-completions arg (if (consp symbols)
+                                symbols
+                              (cdr (assq symbols company-keywords-alist))))))
+    (sorted t)))
+
+(provide 'company-keywords)
+;;; company-keywords.el ends here

.emacs.d/elpa/company-20171122.716/company-nxml.el

@@ -0,0 +1,142 @@
+;;; company-nxml.el --- company-mode completion backend for nxml-mode
+
+;; Copyright (C) 2009-2011, 2013  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defvar rng-open-elements)
+(defvar rng-validate-mode)
+(defvar rng-in-attribute-regex)
+(defvar rng-in-attribute-value-regex)
+(declare-function rng-set-state-after "rng-nxml")
+(declare-function rng-match-possible-start-tag-names "rng-match")
+(declare-function rng-adjust-state-for-attribute "rng-nxml")
+(declare-function rng-match-possible-attribute-names "rng-match")
+(declare-function rng-adjust-state-for-attribute-value "rng-nxml")
+(declare-function rng-match-possible-value-strings "rng-match")
+
+(defconst company-nxml-token-regexp
+  "\\(?:[_[:alpha:]][-._[:alnum:]]*\\_>\\)")
+
+(defvar company-nxml-in-attribute-value-regexp
+  (replace-regexp-in-string "w" company-nxml-token-regexp
+   "<w\\(?::w\\)?\
+\\(?:[ \t\r\n]+w\\(?::w\\)?[ \t\r\n]*=\
+\[ \t\r\n]*\\(?:\"[^\"]*\"\\|'[^']*'\\)\\)*\
+\[ \t\r\n]+\\(w\\(:w\\)?\\)[ \t\r\n]*=[ \t\r\n]*\
+\\(\"\\([^\"]*\\>\\)\\|'\\([^']*\\>\\)\\)\\="
+   t t))
+
+(defvar company-nxml-in-tag-name-regexp
+  (replace-regexp-in-string "w" company-nxml-token-regexp
+                            "<\\(/?w\\(?::w?\\)?\\)?\\=" t t))
+
+(defun company-nxml-all-completions (prefix alist)
+  (let ((candidates (mapcar 'cdr alist))
+        (case-fold-search nil)
+        filtered)
+    (when (cdar rng-open-elements)
+      (push (concat "/" (cdar rng-open-elements)) candidates))
+    (setq candidates (sort (all-completions prefix candidates) 'string<))
+    (while candidates
+      (unless (equal (car candidates) (car filtered))
+        (push (car candidates) filtered))
+      (pop candidates))
+    (nreverse filtered)))
+
+(defmacro company-nxml-prepared (&rest body)
+  (declare (indent 0) (debug t))
+  `(let ((lt-pos (save-excursion (search-backward "<" nil t)))
+         xmltok-dtd)
+     (when (and lt-pos (= (rng-set-state-after lt-pos) lt-pos))
+       ,@body)))
+
+(defun company-nxml-tag (command &optional arg &rest ignored)
+  (cl-case command
+    (prefix (and (derived-mode-p 'nxml-mode)
+                 rng-validate-mode
+                 (company-grab company-nxml-in-tag-name-regexp 1)))
+    (candidates (company-nxml-prepared
+                 (company-nxml-all-completions
+                  arg (rng-match-possible-start-tag-names))))
+    (sorted t)))
+
+(defun company-nxml-attribute (command &optional arg &rest ignored)
+  (cl-case command
+    (prefix (and (derived-mode-p 'nxml-mode)
+                 rng-validate-mode
+                 (memq (char-after) '(?\  ?\t ?\n)) ;; outside word
+                 (company-grab rng-in-attribute-regex 1)))
+    (candidates (company-nxml-prepared
+                 (and (rng-adjust-state-for-attribute
+                       lt-pos (- (point) (length arg)))
+                      (company-nxml-all-completions
+                       arg (rng-match-possible-attribute-names)))))
+    (sorted t)))
+
+(defun company-nxml-attribute-value (command &optional arg &rest ignored)
+  (cl-case command
+    (prefix (and (derived-mode-p 'nxml-mode)
+                 rng-validate-mode
+                 (and (memq (char-after) '(?' ?\" ?\  ?\t ?\n)) ;; outside word
+                      (looking-back company-nxml-in-attribute-value-regexp nil)
+                      (or (match-string-no-properties 4)
+                          (match-string-no-properties 5)
+                          ""))))
+    (candidates (company-nxml-prepared
+                 (let (attr-start attr-end colon)
+                   (and (looking-back rng-in-attribute-value-regex lt-pos)
+                        (setq colon (match-beginning 2)
+                              attr-start (match-beginning 1)
+                              attr-end (match-end 1))
+                        (rng-adjust-state-for-attribute lt-pos attr-start)
+                        (rng-adjust-state-for-attribute-value
+                         attr-start colon attr-end)
+                        (all-completions
+                         arg (rng-match-possible-value-strings))))))))
+
+;;;###autoload
+(defun company-nxml (command &optional arg &rest ignored)
+  "`company-mode' completion backend for `nxml-mode'."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-nxml))
+    (prefix (or (company-nxml-tag 'prefix)
+                (company-nxml-attribute 'prefix)
+                (company-nxml-attribute-value 'prefix)))
+    (candidates (cond
+                 ((company-nxml-tag 'prefix)
+                  (company-nxml-tag 'candidates arg))
+                 ((company-nxml-attribute 'prefix)
+                  (company-nxml-attribute 'candidates arg))
+                 ((company-nxml-attribute-value 'prefix)
+                  (sort (company-nxml-attribute-value 'candidates arg)
+                        'string<))))
+    (sorted t)))
+
+(provide 'company-nxml)
+;;; company-nxml.el ends here

.emacs.d/elpa/company-20171122.716/company-oddmuse.el

@@ -0,0 +1,57 @@
+;;; company-oddmuse.el --- company-mode completion backend for oddmuse-mode
+
+;; Copyright (C) 2009-2011, 2014  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(eval-when-compile (require 'yaoddmuse nil t))
+(eval-when-compile (require 'oddmuse nil t))
+
+(defvar company-oddmuse-link-regexp
+  "\\(\\<[A-Z][[:alnum:]]*\\>\\)\\|\\[\\[\\([[:alnum:]]+\\>\\|\\)")
+
+(defun company-oddmuse-get-page-table ()
+  (cl-case major-mode
+    (yaoddmuse-mode (with-no-warnings
+                      (yaoddmuse-get-pagename-table yaoddmuse-wikiname)))
+    (oddmuse-mode (with-no-warnings
+                    (oddmuse-make-completion-table oddmuse-wiki)))))
+
+;;;###autoload
+(defun company-oddmuse (command &optional arg &rest ignored)
+  "`company-mode' completion backend for `oddmuse-mode'."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-oddmuse))
+    (prefix (let ((case-fold-search nil))
+              (and (memq major-mode '(oddmuse-mode yaoddmuse-mode))
+                   (looking-back company-oddmuse-link-regexp (point-at-bol))
+                   (or (match-string 1)
+                       (match-string 2)))))
+    (candidates (all-completions arg (company-oddmuse-get-page-table)))))
+
+(provide 'company-oddmuse)
+;;; company-oddmuse.el ends here

.emacs.d/elpa/company-20171122.716/company-pkg.el

@@ -0,0 +1,7 @@
+(define-package "company" "20171122.716" "Modular text completion framework"
+  '((emacs "24.3"))
+  :url "http://company-mode.github.io/" :keywords
+  '("abbrev" "convenience" "matching"))
+;; Local Variables:
+;; no-byte-compile: t
+;; End:

.emacs.d/elpa/company-20171122.716/company-semantic.el

@@ -0,0 +1,167 @@
+;;; company-semantic.el --- company-mode completion backend using Semantic
+
+;; Copyright (C) 2009-2011, 2013-2016  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'company-template)
+(require 'cl-lib)
+
+(defvar semantic-idle-summary-function)
+(declare-function semantic-documentation-for-tag "semantic/doc" )
+(declare-function semantic-analyze-current-context "semantic/analyze")
+(declare-function semantic-analyze-possible-completions "semantic/complete")
+(declare-function semantic-analyze-find-tags-by-prefix "semantic/analyze/fcn")
+(declare-function semantic-tag-class "semantic/tag")
+(declare-function semantic-tag-name "semantic/tag")
+(declare-function semantic-tag-start "semantic/tag")
+(declare-function semantic-tag-buffer "semantic/tag")
+(declare-function semantic-active-p "semantic")
+(declare-function semantic-format-tag-prototype "semantic/format")
+
+(defgroup company-semantic nil
+  "Completion backend using Semantic."
+  :group 'company)
+
+(defcustom company-semantic-metadata-function 'company-semantic-summary-and-doc
+  "The function turning a semantic tag into doc information."
+  :type 'function)
+
+(defcustom company-semantic-begin-after-member-access t
+  "When non-nil, automatic completion will start whenever the current
+symbol is preceded by \".\", \"->\" or \"::\", ignoring
+`company-minimum-prefix-length'.
+
+If `company-begin-commands' is a list, it should include `c-electric-lt-gt'
+and `c-electric-colon', for automatic completion right after \">\" and
+\":\".")
+
+(defcustom company-semantic-insert-arguments t
+  "When non-nil, insert function arguments as a template after completion."
+  :type 'boolean
+  :package-version '(company . "0.9.0"))
+
+(defvar company-semantic-modes '(c-mode c++-mode jde-mode java-mode))
+
+(defvar-local company-semantic--current-tags nil
+  "Tags for the current context.")
+
+(defun company-semantic-documentation-for-tag (tag)
+  (when (semantic-tag-buffer tag)
+    ;; When TAG's buffer is unknown, the function below raises an error.
+    (semantic-documentation-for-tag tag)))
+
+(defun company-semantic-doc-or-summary (tag)
+  (or (company-semantic-documentation-for-tag tag)
+      (and (require 'semantic-idle nil t)
+           (require 'semantic/idle nil t)
+           (funcall semantic-idle-summary-function tag nil t))))
+
+(defun company-semantic-summary-and-doc (tag)
+  (let ((doc (company-semantic-documentation-for-tag tag))
+        (summary (funcall semantic-idle-summary-function tag nil t)))
+    (and (stringp doc)
+         (string-match "\n*\\(.*\\)$" doc)
+         (setq doc (match-string 1 doc)))
+    (concat summary
+            (when doc
+                  (if (< (+ (length doc) (length summary) 4) (window-width))
+                      " -- "
+                    "\n"))
+            doc)))
+
+(defun company-semantic-doc-buffer (tag)
+  (let ((doc (company-semantic-documentation-for-tag tag)))
+    (when doc
+      (company-doc-buffer
+       (concat (funcall semantic-idle-summary-function tag nil t)
+               "\n"
+               doc)))))
+
+(defsubst company-semantic-completions (prefix)
+  (ignore-errors
+    (let ((completion-ignore-case nil)
+          (context (semantic-analyze-current-context)))
+      (setq company-semantic--current-tags
+            (semantic-analyze-possible-completions context 'no-unique))
+      (all-completions prefix company-semantic--current-tags))))
+
+(defun company-semantic-completions-raw (prefix)
+  (setq company-semantic--current-tags nil)
+  (dolist (tag (semantic-analyze-find-tags-by-prefix prefix))
+    (unless (eq (semantic-tag-class tag) 'include)
+      (push tag company-semantic--current-tags)))
+  (delete "" (mapcar 'semantic-tag-name company-semantic--current-tags)))
+
+(defun company-semantic-annotation (argument tags)
+  (let* ((tag (assq argument tags))
+         (kind (when tag (elt tag 1))))
+    (cl-case kind
+      (function (let* ((prototype (semantic-format-tag-prototype tag nil nil))
+                       (par-pos (string-match "(" prototype)))
+                  (when par-pos (substring prototype par-pos)))))))
+
+(defun company-semantic--prefix ()
+  (if company-semantic-begin-after-member-access
+      (company-grab-symbol-cons "\\.\\|->\\|::" 2)
+    (company-grab-symbol)))
+
+;;;###autoload
+(defun company-semantic (command &optional arg &rest ignored)
+  "`company-mode' completion backend using CEDET Semantic."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-semantic))
+    (prefix (and (featurep 'semantic)
+                 (semantic-active-p)
+                 (memq major-mode company-semantic-modes)
+                 (not (company-in-string-or-comment))
+                 (or (company-semantic--prefix) 'stop)))
+    (candidates (if (and (equal arg "")
+                         (not (looking-back "->\\|\\.\\|::" (- (point) 2))))
+                    (company-semantic-completions-raw arg)
+                  (company-semantic-completions arg)))
+    (meta (funcall company-semantic-metadata-function
+                   (assoc arg company-semantic--current-tags)))
+    (annotation (company-semantic-annotation arg
+                                             company-semantic--current-tags))
+    (doc-buffer (company-semantic-doc-buffer
+                 (assoc arg company-semantic--current-tags)))
+    ;; Because "" is an empty context and doesn't return local variables.
+    (no-cache (equal arg ""))
+    (duplicates t)
+    (location (let ((tag (assoc arg company-semantic--current-tags)))
+                (when (buffer-live-p (semantic-tag-buffer tag))
+                  (cons (semantic-tag-buffer tag)
+                        (semantic-tag-start tag)))))
+    (post-completion (let ((anno (company-semantic-annotation
+                                  arg company-semantic--current-tags)))
+                       (when (and company-semantic-insert-arguments anno)
+                         (insert anno)
+                         (company-template-c-like-templatify (concat arg anno)))
+                       ))))
+
+(provide 'company-semantic)
+;;; company-semantic.el ends here

.emacs.d/elpa/company-20171122.716/company-template.el

@@ -0,0 +1,260 @@
+;;; company-template.el --- utility library for template expansion
+
+;; Copyright (C) 2009, 2010, 2014-2017 Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Code:
+
+(require 'cl-lib)
+
+(defface company-template-field
+  '((((background dark)) (:background "yellow" :foreground "black"))
+    (((background light)) (:background "orange" :foreground "black")))
+  "Face used for editable text in template fields."
+  :group 'company)
+
+(defvar company-template-nav-map
+  (let ((keymap (make-sparse-keymap)))
+    (define-key keymap [tab] 'company-template-forward-field)
+    (define-key keymap (kbd "TAB") 'company-template-forward-field)
+    keymap))
+
+(defvar company-template-field-map
+  (let ((keymap (make-sparse-keymap)))
+    (set-keymap-parent keymap company-template-nav-map)
+    (define-key keymap (kbd "C-d") 'company-template-clear-field)
+    keymap))
+
+(defvar-local company-template--buffer-templates nil)
+
+;; interactive ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-templates-at (pos)
+  (let (os)
+    (dolist (o (overlays-at pos))
+      ;; FIXME: Always return the whole list of templates?
+      ;; We remove templates not at point after every command.
+      (when (memq o company-template--buffer-templates)
+        (push o os)))
+    os))
+
+(defun company-template-move-to-first (templ)
+  (interactive)
+  (goto-char (overlay-start templ))
+  (company-template-forward-field))
+
+(defun company-template-forward-field ()
+  (interactive)
+  (let ((start (point))
+        (next-field-start (company-template-find-next-field)))
+    (push-mark)
+    (goto-char next-field-start)
+    (company-template-remove-field (company-template-field-at start))))
+
+(defun company-template-clear-field ()
+  "Clear the field at point."
+  (interactive)
+  (let ((ovl (company-template-field-at (point))))
+    (when ovl
+      (company-template-remove-field ovl t)
+      (let ((after-clear-fn
+             (overlay-get ovl 'company-template-after-clear)))
+        (when (functionp after-clear-fn)
+          (funcall after-clear-fn))))))
+
+(defun company-template--after-clear-c-like-field ()
+  "Function that can be called after deleting a field of a c-like template.
+For c-like templates it is set as `after-post-fn' property on fields in
+`company-template-add-field'.  If there is a next field, delete everything
+from point to it.  If there is no field after point, remove preceding comma
+if present."
+  (let* ((pos (point))
+         (next-field-start (company-template-find-next-field))
+         (last-field-p (not (company-template-field-at next-field-start))))
+    (cond ((and (not last-field-p)
+                (< pos next-field-start)
+                (string-match "^[ ]*,+[ ]*$" (buffer-substring-no-properties
+                                              pos next-field-start)))
+           (delete-region pos next-field-start))
+          ((and last-field-p
+                (looking-back ",+[ ]*" (line-beginning-position)))
+           (delete-region (match-beginning 0) pos)))))
+
+(defun company-template-find-next-field ()
+  (let* ((start (point))
+         (templates (company-template-templates-at start))
+         (minimum (apply 'max (mapcar 'overlay-end templates)))
+         (fields (cl-loop for templ in templates
+                          append (overlay-get templ 'company-template-fields))))
+    (dolist (pos (mapcar 'overlay-start fields) minimum)
+      (and pos
+           (> pos start)
+           (< pos minimum)
+           (setq minimum pos)))))
+
+(defun company-template-field-at (&optional point)
+  (cl-loop for ovl in (overlays-at (or point (point)))
+           when (overlay-get ovl 'company-template-parent)
+           return ovl))
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-declare-template (beg end)
+  (let ((ov (make-overlay beg end)))
+    ;; (overlay-put ov 'face 'highlight)
+    (overlay-put ov 'keymap company-template-nav-map)
+    (overlay-put ov 'priority 101)
+    (overlay-put ov 'evaporate t)
+    (push ov company-template--buffer-templates)
+    (add-hook 'post-command-hook 'company-template-post-command nil t)
+    ov))
+
+(defun company-template-remove-template (templ)
+  (mapc 'company-template-remove-field
+        (overlay-get templ 'company-template-fields))
+  (setq company-template--buffer-templates
+        (delq templ company-template--buffer-templates))
+  (delete-overlay templ))
+
+(defun company-template-add-field (templ beg end &optional display after-clear-fn)
+  "Add new field to template TEMPL spanning from BEG to END.
+When DISPLAY is non-nil, set the respective property on the overlay.
+Leave point at the end of the field.
+AFTER-CLEAR-FN is a function that can be used to apply custom behavior
+after deleting a field in `company-template-remove-field'."
+  (cl-assert templ)
+  (when (> end (overlay-end templ))
+    (move-overlay templ (overlay-start templ) end))
+  (let ((ov (make-overlay beg end))
+        (siblings (overlay-get templ 'company-template-fields)))
+    ;; (overlay-put ov 'evaporate t)
+    (overlay-put ov 'intangible t)
+    (overlay-put ov 'face 'company-template-field)
+    (when display
+      (overlay-put ov 'display display))
+    (overlay-put ov 'company-template-parent templ)
+    (overlay-put ov 'insert-in-front-hooks '(company-template-insert-hook))
+    (when after-clear-fn
+      (overlay-put ov 'company-template-after-clear after-clear-fn))
+    (overlay-put ov 'keymap company-template-field-map)
+    (overlay-put ov 'priority 101)
+    (push ov siblings)
+    (overlay-put templ 'company-template-fields siblings)))
+
+(defun company-template-remove-field (ovl &optional clear)
+  (when (overlayp ovl)
+    (when (overlay-buffer ovl)
+      (when clear
+        (delete-region (overlay-start ovl) (overlay-end ovl)))
+      (delete-overlay ovl))
+    (let* ((templ (overlay-get ovl 'company-template-parent))
+           (siblings (overlay-get templ 'company-template-fields)))
+      (setq siblings (delq ovl siblings))
+      (overlay-put templ 'company-template-fields siblings))))
+
+(defun company-template-clean-up (&optional pos)
+  "Clean up all templates that don't contain POS."
+  (let ((local-ovs (overlays-at (or pos (point)))))
+    (dolist (templ company-template--buffer-templates)
+      (unless (memq templ local-ovs)
+        (company-template-remove-template templ)))))
+
+;; hooks ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-insert-hook (ovl after-p &rest _ignore)
+  "Called when a snippet input prompt is modified."
+  (unless after-p
+    (company-template-remove-field ovl t)))
+
+(defun company-template-post-command ()
+  (company-template-clean-up)
+  (unless company-template--buffer-templates
+    (remove-hook 'post-command-hook 'company-template-post-command t)))
+
+;; common ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-c-like-templatify (call)
+  (let* ((end (point-marker))
+         (beg (- (point) (length call)))
+         (templ (company-template-declare-template beg end))
+         paren-open paren-close)
+    (with-syntax-table (make-syntax-table (syntax-table))
+      (modify-syntax-entry ?< "(")
+      (modify-syntax-entry ?> ")")
+      (when (search-backward ")" beg t)
+        (setq paren-close (point-marker))
+        (forward-char 1)
+        (delete-region (point) end)
+        (backward-sexp)
+        (forward-char 1)
+        (setq paren-open (point-marker)))
+      (when (search-backward ">" beg t)
+        (let ((angle-close (point-marker)))
+          (forward-char 1)
+          (backward-sexp)
+          (forward-char)
+          (company-template--c-like-args templ angle-close)))
+      (when (looking-back "\\((\\*)\\)(" (line-beginning-position))
+        (delete-region (match-beginning 1) (match-end 1)))
+      (when paren-open
+        (goto-char paren-open)
+        (company-template--c-like-args templ paren-close)))
+    (if (overlay-get templ 'company-template-fields)
+        (company-template-move-to-first templ)
+      (company-template-remove-template templ)
+      (goto-char end))))
+
+(defun company-template--c-like-args (templ end)
+  (let ((last-pos (point)))
+    (while (re-search-forward "\\([^,]+\\),?" end 'move)
+      (when (zerop (car (parse-partial-sexp last-pos (point))))
+        (company-template-add-field templ last-pos (match-end 1) nil
+                                    #'company-template--after-clear-c-like-field)
+        (skip-chars-forward " ")
+        (setq last-pos (point))))))
+
+;; objc ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-template-objc-templatify (selector)
+  (let* ((end (point-marker))
+         (beg (- (point) (length selector) 1))
+         (templ (company-template-declare-template beg end))
+         (cnt 0))
+    (save-excursion
+      (goto-char beg)
+      (catch 'stop
+        (while (search-forward ":" end t)
+          (if (looking-at "\\(([^)]*)\\) ?")
+              (company-template-add-field templ (point) (match-end 1))
+            ;; Not sure which conditions this case manifests under, but
+            ;; apparently it did before, when I wrote the first test for this
+            ;; function.  FIXME: Revisit it.
+            (company-template-add-field templ (point)
+                                        (progn
+                                          (insert (format "arg%d" cnt))
+                                          (point)))
+            (when (< (point) end)
+              (insert " "))
+            (cl-incf cnt))
+          (when (>= (point) end)
+            (throw 'stop t)))))
+    (company-template-move-to-first templ)))
+
+(provide 'company-template)
+;;; company-template.el ends here

.emacs.d/elpa/company-20171122.716/company-tempo.el

@@ -0,0 +1,71 @@
+;;; company-tempo.el --- company-mode completion backend for tempo
+
+;; Copyright (C) 2009-2011, 2015  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+(require 'tempo)
+
+(defgroup company-tempo nil
+  "Tempo completion backend."
+  :group 'company)
+
+(defcustom company-tempo-expand nil
+  "Whether to expand a tempo tag after completion."
+  :type '(choice (const :tag "Off" nil)
+                 (const :tag "On" t)))
+
+(defsubst company-tempo-lookup (match)
+  (cdr (assoc match (tempo-build-collection))))
+
+(defun company-tempo-insert (match)
+  "Replace MATCH with the expanded tempo template."
+  (search-backward match)
+  (goto-char (match-beginning 0))
+  (replace-match "")
+  (call-interactively (company-tempo-lookup match)))
+
+(defsubst company-tempo-meta (match)
+  (let ((templ (company-tempo-lookup match))
+        doc)
+    (and templ
+         (setq doc (documentation templ t))
+         (car (split-string doc "\n" t)))))
+
+;;;###autoload
+(defun company-tempo (command &optional arg &rest ignored)
+  "`company-mode' completion backend for tempo."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-tempo))
+    (prefix (or (car (tempo-find-match-string tempo-match-finder)) ""))
+    (candidates (all-completions arg (tempo-build-collection)))
+    (meta (company-tempo-meta arg))
+    (post-completion (when company-tempo-expand (company-tempo-insert arg)))
+    (sorted t)))
+
+(provide 'company-tempo)
+;;; company-tempo.el ends here

.emacs.d/elpa/company-20171122.716/company-tng.el

@@ -0,0 +1,159 @@
+;;; company-tng.el --- company-mode configuration for single-button interaction
+
+;; Copyright (C) 2017  Free Software Foundation, Inc.
+
+;; Author: Nikita Leshenko
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+;; company-tng (Tab and Go) allows you to perform completion using just TAB.
+;; Pressing it will both select the next completion candidate in the list and
+;; insert it into the buffer (or make it look like it's inserted, in fact).
+;;
+;; It cycles the candidates like `yank-pop' or `dabbrev-expand' or Vim:
+;; Pressing TAB selects the first item in the completion menu and inserts it in
+;; the buffer. Pressing TAB again selects the second item and replaces the
+;; "inserted" item with the second one. This can continue as long as the user
+;; wishes to cycle through the menu. You can also press S-TAB to select the
+;; previous candidate, of course.
+;;
+;; The benefits are that you only have to use one shortcut key and there is no
+;; need to confirm the entry.
+;;
+;; Usage:
+;;
+;; To apply the default configuration for company-tng call
+;; `company-tng-configure-default' from your init script.
+;;
+;; You can also configure company-tng manually:
+;;
+;; Add `company-tng-frontend' to `company-frontends':
+;;
+;;   (add-to-list 'company-frontends 'company-tng-frontend)
+;;
+;; We recommend to bind TAB to `company-select-next', S-TAB to
+;; `company-select-previous', and unbind RET and other now-unnecessary
+;; keys from `company-active-map':
+;;
+;;   (define-key company-active-map (kbd "TAB") 'company-select-next)
+;;   (define-key company-active-map (kbd "<backtab>") 'company-select-previous)
+;;   (define-key company-active-map (kbd "RET") nil)
+;;
+;; Note that it's not necessary to rebind keys to use this frontend,
+;; you can use the arrow keys or M-n/M-p to select and insert
+;; candidates. You also need to decide which keys to unbind, depending
+;; on whether you want them to do the Company action or the default
+;; Emacs action (for example C-s or C-w).
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defvar-local company-tng--overlay nil)
+
+;;;###autoload
+(defun company-tng-frontend (command)
+  "When the user changes the selection at least once, this
+frontend will display the candidate in the buffer as if it's
+already there and any key outside of `company-active-map' will
+confirm the selection and finish the completion."
+  (cl-case command
+    (show
+     (let ((ov (make-overlay (point) (point))))
+       (setq company-tng--overlay ov)
+       (overlay-put ov 'priority 2))
+     (advice-add 'company-select-next :before-until 'company-tng--allow-unselected)
+     (advice-add 'company-fill-propertize :filter-args 'company-tng--adjust-tooltip-highlight))
+    (update
+     (let ((ov company-tng--overlay)
+           (selected (nth company-selection company-candidates))
+           (prefix (length company-prefix)))
+       (move-overlay ov (- (point) prefix) (point))
+       (overlay-put ov
+                    (if (= prefix 0) 'after-string 'display)
+                    (and company-selection-changed selected))))
+    (hide
+     (when company-tng--overlay
+       (delete-overlay company-tng--overlay)
+       (kill-local-variable 'company-tng--overlay))
+     (advice-remove 'company-select-next 'company-tng--allow-unselected)
+     (advice-remove 'company-fill-propertize 'company-tng--adjust-tooltip-highlight))
+    (pre-command
+     (when (and company-selection-changed
+                (not (company--company-command-p (this-command-keys))))
+       (company--unread-this-command-keys)
+       (setq this-command 'company-complete-selection)))))
+
+;;;###autoload
+(defun company-tng-configure-default ()
+  "Applies the default configuration to enable company-tng."
+  (setq company-frontends '(company-tng-frontend
+                            company-pseudo-tooltip-frontend
+                            company-echo-metadata-frontend))
+  (let ((keymap company-active-map))
+    (define-key keymap [return] nil)
+    (define-key keymap (kbd "RET") nil)
+    (define-key keymap [tab] 'company-select-next)
+    (define-key keymap (kbd "TAB") 'company-select-next)
+    (define-key keymap [backtab] 'company-select-previous)
+    (define-key keymap (kbd "S-TAB") 'company-select-previous)))
+
+(defun company-tng--allow-unselected (&optional arg)
+  "Advice `company-select-next' to allow for an 'unselected'
+state. Unselected means that no user interaction took place on the
+completion candidates and it's marked by setting
+`company-selection-changed' to nil. This advice will call the underlying
+`company-select-next' unless we need to transition to or from an unselected
+state.
+
+Possible state transitions:
+- (arg > 0) unselected -> first candidate selected
+- (arg < 0) first candidate selected -> unselected
+- (arg < 0 wrap-round) unselected -> last candidate selected
+- (arg < 0 no wrap-round) unselected -> unselected
+
+There is no need to advice `company-select-previous' because it calls
+`company-select-next' internally."
+  (cond
+   ;; Selecting next
+   ((or (not arg) (> arg 0))
+    (unless company-selection-changed
+      (company-set-selection (1- (or arg 1)) 'force-update)
+      t))
+   ;; Selecting previous
+   ((< arg 0)
+    (when (and company-selection-changed
+               (< (+ company-selection arg) 0))
+      (company-set-selection 0)
+      (setq company-selection-changed nil)
+      (company-call-frontends 'update)
+      t)
+    )))
+
+(defun company-tng--adjust-tooltip-highlight (args)
+  "Prevent the tooltip from highlighting the current selection if it wasn't
+made explicitly (i.e. `company-selection-changed' is true)"
+  (unless company-selection-changed
+    ;; The 4th arg of `company-fill-propertize' is selected
+    (setf (nth 3 args) nil))
+  args)
+
+(provide 'company-tng)
+;;; company-tng.el ends here

.emacs.d/elpa/company-20171122.716/company-xcode.el

@@ -0,0 +1,123 @@
+;;; company-xcode.el --- company-mode completion backend for Xcode projects
+
+;; Copyright (C) 2009-2011, 2014  Free Software Foundation, Inc.
+
+;; Author: Nikolaj Schumacher
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(defgroup company-xcode nil
+  "Completion backend for Xcode projects."
+  :group 'company)
+
+(defcustom company-xcode-xcodeindex-executable (executable-find "xcodeindex")
+  "Location of xcodeindex executable."
+  :type 'file)
+
+(defvar company-xcode-tags nil)
+
+(defun company-xcode-reset ()
+  "Reset the cached tags."
+  (interactive)
+  (setq company-xcode-tags nil))
+
+(defcustom company-xcode-types
+  '("Class" "Constant" "Enum" "Macro" "Modeled Class" "Structure"
+    "Type" "Union" "Function")
+  "The types of symbols offered by `company-xcode'.
+No context-enabled completion is available.  Types like methods will be
+offered regardless of whether the class supports them.  The defaults should be
+valid in most contexts."
+  :set (lambda (variable value)
+         (set variable value)
+         (company-xcode-reset))
+  :type '(set (const "Category") (const "Class") (const "Class Method")
+              (const "Class Variable") (const "Constant") (const "Enum")
+              (const "Field") (const "Instance Method")
+              (const "Instance Variable") (const "Macro")
+              (const "Modeled Class") (const "Modeled Method")
+              (const "Modeled Property") (const "Property") (const "Protocol")
+              (const "Structure") (const "Type") (const "Union")
+              (const "Variable") (const "Function")))
+
+(defvar-local company-xcode-project 'unknown)
+
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+
+(defun company-xcode-fetch (project-bundle)
+  (setq project-bundle (directory-file-name project-bundle))
+  (message "Retrieving dump from %s..." project-bundle)
+  (with-temp-buffer
+    (let ((default-directory (file-name-directory project-bundle)))
+      (call-process company-xcode-xcodeindex-executable nil (current-buffer)
+                    nil "dump" "-project"
+                    (file-name-nondirectory project-bundle) "-quiet")
+      (goto-char (point-min))
+      (let ((regexp (concat "^\\([^\t\n]*\\)\t[^\t\n]*\t"
+                            (regexp-opt company-xcode-types)
+                            "\t[^\t\n]*\t[^\t\n]*"))
+            candidates)
+        (while (re-search-forward regexp nil t)
+          (cl-pushnew (match-string 1) candidates :test #'equal))
+        (message "Retrieving dump from %s...done" project-bundle)
+        candidates))))
+
+(defun company-xcode-find-project ()
+  (let ((dir (if buffer-file-name
+                 (file-name-directory buffer-file-name)
+               (expand-file-name default-directory)))
+        (prev-dir nil)
+        file)
+    (while (not (or file (equal dir prev-dir)))
+      (setq file (car (directory-files dir t ".xcodeproj\\'" t))
+            prev-dir dir
+            dir (file-name-directory (directory-file-name dir))))
+    file))
+
+(defun company-xcode-tags ()
+  (when (eq company-xcode-project 'unknown)
+    (setq company-xcode-project (company-xcode-find-project)))
+  (when company-xcode-project
+    (cdr (or (assoc company-xcode-project company-xcode-tags)
+             (car (push (cons company-xcode-project
+                              (company-xcode-fetch company-xcode-project))
+                        company-xcode-tags))))))
+;;;###autoload
+(defun company-xcode (command &optional arg &rest ignored)
+  "`company-mode' completion backend for Xcode projects."
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-xcode))
+    (prefix (and company-xcode-xcodeindex-executable
+                 (company-xcode-tags)
+                 (not (company-in-string-or-comment))
+                 (or (company-grab-symbol) 'stop)))
+    (candidates (let ((completion-ignore-case nil))
+                  (company-xcode-tags)
+                  (all-completions arg (company-xcode-tags))))))
+
+
+(provide 'company-xcode)
+;;; company-xcode.el ends here

.emacs.d/elpa/company-20171122.716/company-yasnippet.el

@@ -0,0 +1,147 @@
+;;; company-yasnippet.el --- company-mode completion backend for Yasnippet
+
+;; Copyright (C) 2014, 2015  Free Software Foundation, Inc.
+
+;; Author: Dmitry Gutov
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs is free software: you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; GNU Emacs is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+
+;;; Commentary:
+;;
+
+;;; Code:
+
+(require 'company)
+(require 'cl-lib)
+
+(declare-function yas--table-hash "yasnippet")
+(declare-function yas--get-snippet-tables "yasnippet")
+(declare-function yas-expand-snippet "yasnippet")
+(declare-function yas--template-content "yasnippet")
+(declare-function yas--template-expand-env "yasnippet")
+(declare-function yas--warning "yasnippet")
+
+(defun company-yasnippet--key-prefixes ()
+  ;; Mostly copied from `yas--templates-for-key-at-point'.
+  (defvar yas-key-syntaxes)
+  (save-excursion
+    (let ((original (point))
+          (methods yas-key-syntaxes)
+          prefixes
+          method)
+      (while methods
+        (unless (eq method (car methods))
+          (goto-char original))
+        (setq method (car methods))
+        (cond ((stringp method)
+               (skip-syntax-backward method)
+               (setq methods (cdr methods)))
+              ((functionp method)
+               (unless (eq (funcall method original)
+                           'again)
+                 (setq methods (cdr methods))))
+              (t
+               (setq methods (cdr methods))
+               (yas--warning "Invalid element `%s' in `yas-key-syntaxes'" method)))
+        (let ((prefix (buffer-substring-no-properties (point) original)))
+          (unless (equal prefix (car prefixes))
+            (push prefix prefixes))))
+      prefixes)))
+
+(defun company-yasnippet--candidates (prefix)
+  ;; Process the prefixes in reverse: unlike Yasnippet, we look for prefix
+  ;; matches, so the longest prefix with any matches should be the most useful.
+  (cl-loop with tables = (yas--get-snippet-tables)
+           for key-prefix in (company-yasnippet--key-prefixes)
+           ;; Only consider keys at least as long as the symbol at point.
+           when (>= (length key-prefix) (length prefix))
+           thereis (company-yasnippet--completions-for-prefix prefix
+                                                              key-prefix
+                                                              tables)))
+
+(defun company-yasnippet--completions-for-prefix (prefix key-prefix tables)
+  (cl-mapcan
+   (lambda (table)
+     (let ((keyhash (yas--table-hash table))
+           res)
+       (when keyhash
+         (maphash
+          (lambda (key value)
+            (when (and (stringp key)
+                       (string-prefix-p key-prefix key))
+              (maphash
+               (lambda (name template)
+                 (push
+                  (propertize key
+                              'yas-annotation name
+                              'yas-template template
+                              'yas-prefix-offset (- (length key-prefix)
+                                                    (length prefix)))
+                  res))
+               value)))
+          keyhash))
+       res))
+   tables))
+
+;;;###autoload
+(defun company-yasnippet (command &optional arg &rest ignore)
+  "`company-mode' backend for `yasnippet'.
+
+This backend should be used with care, because as long as there are
+snippets defined for the current major mode, this backend will always
+shadow backends that come after it.  Recommended usages:
+
+* In a buffer-local value of `company-backends', grouped with a backend or
+  several that provide actual text completions.
+
+  (add-hook 'js-mode-hook
+            (lambda ()
+              (set (make-local-variable 'company-backends)
+                   '((company-dabbrev-code company-yasnippet)))))
+
+* After keyword `:with', grouped with other backends.
+
+  (push '(company-semantic :with company-yasnippet) company-backends)
+
+* Not in `company-backends', just bound to a key.
+
+  (global-set-key (kbd \"C-c y\") 'company-yasnippet)
+"
+  (interactive (list 'interactive))
+  (cl-case command
+    (interactive (company-begin-backend 'company-yasnippet))
+    (prefix
+     ;; Should probably use `yas--current-key', but that's bound to be slower.
+     ;; How many trigger keys start with non-symbol characters anyway?
+     (and (bound-and-true-p yas-minor-mode)
+          (company-grab-symbol)))
+    (annotation
+     (concat
+      (unless company-tooltip-align-annotations " -> ")
+      (get-text-property 0 'yas-annotation arg)))
+    (candidates (company-yasnippet--candidates arg))
+    (no-cache t)
+    (post-completion
+     (let ((template (get-text-property 0 'yas-template arg))
+           (prefix-offset (get-text-property 0 'yas-prefix-offset arg)))
+       (yas-expand-snippet (yas--template-content template)
+                           (- (point) (length arg) prefix-offset)
+                           (point)
+                           (yas--template-expand-env template))))))
+
+(provide 'company-yasnippet)
+;;; company-yasnippet.el ends here

.emacs.d/elpa/elpy-20171206.847/NEWS.rst

@@ -0,0 +1,521 @@
+New in Elpy 1.17.0
+==================
+
+- The xref functionality in newer Emacsen is now supported for
+  following symbols at point.
+- Elpy now supports PEP 397 for Windows executable names.
+- In addition to pylint, Elpy now also supports epylint correctly.
+- A number of features for working with interactive Python have been added to
+  Elpy; e.g., commands for sending code fragments to the Python shell and the
+  ability to echo their output in the message area. See the documentation for a
+  full list.
+- Bunch of little bugfixes.
+
+
+New in Elpy 1.16.0
+==================
+
+- You can now change which function is used to run test commands,
+  instead of the default ``compile``, using
+  ``elpy-test-compilation-function``. This allows using ``pdb`` to run
+  tests in a debugger, for example.
+- Elpy now sets ``IPY_TEST_SIMPLE_PROMPT``, which should prevent a
+  number of problems with IPython 5.
+- If you like Elpy, you can now sponsor its development using Patreon
+  at https://www.patreon.com/jorgenschaefer
+
+
+New in Elpy 1.15.0
+==================
+
+- Elpy now supports profiling, try ``elpy-profile-buffer-or-region``!
+- Do not randomly downcase completion candidates anymore.
+- Work around a bug in Emacs 25.1 and before related to current
+  IPython shells.
+- And lots of other bugfixes.
+
+
+New in Elpy 1.14.0
+==================
+
+- Basic Django support. Try ``C-c C-x c`` and ``C-c C-x r``! Thanks to
+  Daniel Gopar for this.
+- You can now use manage.py to run Django tests, instead of always
+  using django-admin.py.
+- When called with a prefix argument ``elpy-importmagic-add-import``
+  will now ask for an alias name to import as.
+
+
+New in Elpy 1.13.0
+==================
+
+- Fewer surprises with syntax checks, ``C-c C-z``, reformatting
+- Improved behavior for reformatting.
+- Improved documentation for IPython. IPython 5 broke a lot of things
+  with Emacs. Use it at your own risk.
+
+
+New in Elpy 1.12.0
+==================
+
+- Some symbols can now be completed with parentheses after them,
+  useful for functions. The heuristic for when to add parentheses and
+  not is not optimal, so this is not enabled by default—customize
+  ``elpy-company-post-completion-function`` to enable this feature.
+- Support dedicated Python shells (one per Python file). You can
+  customized ``elpy-dedicated-shells`` to make this the default.
+- Elpy now uses ``python -m pip`` instead of pip directly to improve
+  interaction with virtualenvs.
+- Support for Python 2.6 has been officially dropped.
+- Display for backend errors has been disabled by default. Jedi has
+  not had a release in a long while, and many bugs have been unfixed.
+  These errors have only caused added workload for Elpy maintainers.
+  The option will be reverted once Jedi has had a new release.
+
+
+New in Elpy 1.11.0
+==================
+
+- Elpy now supports yapf to format your code.
+- You can now adjust whether Elpy should hide modes from the mode line
+  or not using ``elpy-remove-modeline-lighter``
+- When the new option ``elpy-disable-backend-error-display`` is set,
+  Elpy will not show its error pop-up anymore. This can be useful if
+  you run into an annoying bug in Jedi, for example.
+- New command ``elpy-goto-definition-other-window`` on ``C-x 4 M-.``.
+- Expanding ``super`` now gives the short form supported in Python 3.
+- All Rope errors are now caught, as the upstream maintainers did not
+  show interest in distinguishing between malformed input and bugs in
+  their library.
+
+
+New in Elpy 1.10.0
+==================
+
+- Marking the current indentation level at the top level will now mark
+  the whole buffer.
+- The region will be normalized before re-indenting it, making the
+  behavior more predictable for partially marked lines.
+- Using autopep8 on the whole buffer will now keep point (roughly) at
+  the same location as it was.
+- The autopep8 code now also uses the same configuration options as
+  the command line tool.
+- Malformed JSON data from the backend is now handled better.
+- RPC processes are restarted when the current virtualenv changes.
+- Python 3.5 is now officially supported.
+- Flymake will now not be enabled in buffers without file name, where
+  it can't run anyhow, or when the checker program does not exist in
+  the first place.
+- It is now possible to ask Elpy not to remove the mode line lighter
+  of company mode, which can be useful if you use company in other
+  modes.
+- Test discovery now also allows file names without "test" in them to
+  be tested. Classes and methods still require the substring, though.
+- Spurious equals signs at the end of completions from Jedi will now
+  be ignored.
+- Various other bug fixes.
+
+
+New in Elpy 1.9.0
+=================
+
+- Elpy now supports the ``autopep8`` library for automatically
+  formatting Python code. All refactoring-related code is now grouped
+  under ``C-c C-r``. Use ``C-c C-r i`` to fix up imports using
+  importmagic, ``C-c C-r p`` to fix up Python code with autopep8, and
+  ``C-c C-r r`` to bring up the old Rope refactoring menu.
+- ``C-c C-b`` will now select a region containing surrounding lines of
+  the current indentation or more.
+- ``C-c C-z`` in a Python shell will now switch back to the last
+  Python buffer, allowing to use the key to cycle back and forth
+  between the Python buffer and shell.
+- The pattern used for ``C-c C-s`` is now customizeable in
+  ``elpy-rgrep-file-pattern``.
+- ``<C-return>`` now can be used to send the current statement to the
+  Python shell. Be careful, this can break with nested statements.
+- The Elpy minor mode now also works in modes derived from
+  ``python-mode``, not just in the mode itself.
+
+
+New in Elpy 1.8.1
+=================
+
+- Ignore a ``KeyError`` from Jedi 0.9.0 which occurs a lot in normal
+  code.
+
+
+New in Elpy 1.8.0
+=================
+
+- Emacs 24.5 is now officially supported
+- The new configuration option ``elpy-rpc-ignored-buffer-size`` defines a maximum buffer size to be handle completion in, to avoid laggy interaction in unusually large files
+- Indentation block movement was replaced with code that just moves the marked block or the current line; this should be a lot less magical and more predictable
+- Running the test at point now correctly ignores any inner methods
+- Jedi docstrings now show the full name of the object
+- The RPC interpreter is now chosen correctly on cygwin
+- ``elpy-shell-send-region-or-buffer`` now warns of tabs in the data being sent
+- Elpy now binds stdout and stderr to ``/dev/null`` to avoid being confused by spurious output from other libraries
+- RPC buffers (and processes) are removed after some time to avoid them piling up endlessly
+- It is not possibly anymore to use customize alone to use ipython, because of some bad interaction between custom options in Elpy and python.el
+- And lots of bugfixes (50 issues closed!)
+
+
+New in Elpy 1.7.1
+=================
+
+- Do not fail on errors from importmagic.
+- Handle new minor mode behavior of new versions of yasnippet.
+- Do use the argument to ``elpy-use-ipython`` correctly.
+- Handle unexpected data from the backend more gracefully.
+
+
+New in Elpy 1.7.0
+=================
+
+- Elpy now can add missing import directives automatically, by using
+  Alec Thomas' excellent importmagic_ library. Use ``C-c C-m`` to add
+  a single import statement, or ``C-c C-S-m`` to include all missing
+  import statements. Many thanks to Georg Brandl for doing a lot of
+  work to bring this feature to Elpy!
+- The Jedi backend now also supports ``C-c C-d`` to display a
+  docstring. Thanks again to Georg Brandl for the patch.
+- It is now possible to disable the display of the current function in
+  the echo area by setting ``elpy-eldoc-show-current-function`` to
+  ``nil``.
+- idomenu was removed.
+- Twisted's Trial test runner is now supported. Thanks to Elric Milon
+  for the patch!
+- All test runners now use a variable to decide which command to run,
+  which for example allows using ``manage.py`` for the Django test
+  runner, or your own test script which sets up the environment
+  correctly.
+- Emacs 24.4 is now officially supported.
+- Various bugfixes.
+
+.. _importmagic: https://github.com/alecthomas/importmagic
+
+New in Elpy 1.6.0
+=================
+
+- When point is on a line with a flymake error, Elpy will now show the
+  error in the echo area.
+- The movement commands (``C-<cursor>``) have been reworked again.
+  Going left and right will now move by indentation levels left of the
+  current indentation, i.e. jump four spaces, and by words right of
+  the current indentation. Going up and down will go to the previous
+  or next line with the indentation level point is at, not the
+  indentation the line has. Try it, it's more difficult to explain
+  than to use.
+- Completion results are now sorted more sensibly, with
+  single-underscore symbols at the end, and double-underscore symbols
+  after normal symbols, but before single-underscore ones.
+- ``M-x elpy-config`` will now point out if there are newer versions
+  available for packages used by Elpy.
+- ``M-x elpy-config`` will now warn if ``~/.local/bin`` is not in
+  ``PATH`` while there is no virtualenv active.
+- The ``M-x elpy-version`` command is back by popular demand.
+- RPC buffers used by Elpy are now hidden by default, having a space
+  at the beginning of the name.
+- When the Rope library throws an error, Elpy will now also attempt to
+  provide reproduction steps. This used to only happen for Jedi.
+- Various bug fixes.
+
+
+New in Elpy 1.5.1
+=================
+
+- Fix a bug where company-mode might get confused about the current
+  backend, leading to an error about ``Symbol's function definition is
+  void: nil``
+- Fix Rope so it won’t search the whole project directory. This was an
+  intended feature in v1.5 which did not work originally.
+- Use ``yas-text`` instead of ``text`` in snippets for compatibility
+  with the unreleased yasnippet from MELPA (thanks to Daniel Wu!)
+
+New in Elpy 1.5.0
+=================
+
+- Elpy now has a `manual`_. Additionally, there's a menu bar now which
+  should make it easier to discover Elpy features.
+- The Elpy Python package now ships with the Emacs Lisp package,
+  removing the need to install Elpy via pip.
+- Python 3.4 is now officially supported.
+- The new command ``elpy-config`` can be used to configure Elpy using
+  Emacs' built-in customize system. Elpy has been changed to make the
+  most of this.
+- Elpy now uses company-mode instead of auto-complete for on-the-fly
+  auto completion. This changes a few things. There is no automatic
+  documentation popup anymore. Instead, you can type ``C-d`` and get
+  the documentation buffer. In addition, you can type ``C-w`` to see
+  the source of the current candidate in context.
+- Elpy now uses pyvenv as the virtualenv module, enabling
+  virtualenvwrapper hooks.
+- We now ship with a large number of YASnippet snippets. Try ``M-x
+  yas-insert-snippet``.
+- The new unified test running interface on ``C-c C-t`` will try to
+  determine the current test and run it, or, failing that, run all
+  tests. Provide a prefix argument to just run all tests no matter
+  what. You can change the test runner to be used using
+  ``elpy-set-test-runner``. Elpy supports the default unittest
+  discover runner, the Django discover runner, nosetests and py.test
+  by default. New test runners can easily be defined.
+- There's a new multi-edit functionality. ``C-c C-e`` will edit all
+  occurrences of the symbol under point. When using Jedi, this is
+  using semantic information as opposed to just syntactic one. When a
+  region is active, edit all occurrences of the text in region in the
+  current buffer.
+- When sending Python code to the interactive interpreter using ``C-c
+  C-c``, Elpy will now not automatically pop to the interpreter
+  anymore. Use ``C-c C-z`` to switch to the interpreter.
+- Elpy will now display the current class and function if there is no
+  call tip to be displayed. Removes the ``C-c C-q`` binding.
+- If there is a call tip, highlight the current argument (requires Jedi).
+- The documentation interface using ``C-c C-d`` is much smarter now,
+  falling back to pydoc when necessary and providing sensible
+  completion for that, too. Provide a prefix argument if you want no
+  smarts, just pydoc.
+- ``<S-return>`` and ``<C-S-return>`` now open a line below or above
+  the current one.
+- ``<C-cursor>`` will now navigate between Python blocks of the same
+  indentation level. ``<M-cursor>`` will move the current block. Try
+  it, it's easier to understand when you see it than to explain it.
+- There's a new concept of modules. The variable
+  ``elpy-default-minor-modes`` is gone (use ``elpy-mode-hook`` for
+  minor modes). Instead, there's now ``elpy-modules`` which can be
+  used to enable or disable certain features of Elpy.
+- ``elpy-clean-modeline`` is gone, modules now clean themselves up.
+- Elpy now distinguishes between the project root, where project files
+  are located, and the library root, which should be part of
+  ``sys.path`` to import the module under development.
+- ``elpy-project-ignored-directories`` replaces the old
+  ``elpy-rgrep-ignored-directories`` and is used by more features.
+- ``elpy-doc-websearch`` has been removed as it was barely useable
+  as is.
+- Elpy now tries to be more helpful when errors in the backend happen.
+  This removes ``elpy-rpc-traceback``, as that will be displayed by
+  default.
+- Optimizations were added to handle large files, making general
+  interaction a lot faster.
+- When Rope is being used, do not search through unusually large
+  directories. This should speed up interaction in those cases,
+  especially when editing a file in the home directory.
+- And a whole lot of minor bug fixes and little improvements.
+
+.. _manual: https://elpy.readthedocs.io/
+
+
+New in Elpy 1.4.2
+==================
+
+- Minor bugfix to prevent an error from projectile-project-root to
+  interfere with Elpy’s project finding strategy.
+
+New in Elpy 1.4.1
+=================
+
+- Elpy now sets project-wide preferences for Rope, enabling completion
+  in the sys package, among others.
+- An error is avoided in the Jedi backend when trying to go to symbols
+  in compiled packages.
+- A compatibility alias was added for nose.el, which insists on
+  breaking backwards compatibility with Emacs 24.x.
+
+New in Elpy 1.4.0
+=================
+
+- Elpy has moved to its own ELPA. Make sure to update your
+  package-archives (as described above).
+- For a file in a Projectile-managed project is opened, Elpy will now
+  use Projectile’s project root.
+- When the user has set a valid python-check-command, elpy will now
+  refrain from overriding it.
+- On Windows, elpy is now using the pythonw.exe interpreter for the
+  RPC process, as that seems to be causing fewer issues.
+- And various smaller bugfixes.
+
+New in Elpy 1.3.0
+=================
+
+- virtualenv.el has been replaced by pyvenv.el, as that library offers
+  more features.
+- elpy-rpc-restart now works globally, not just in Elpy buffers.
+- Elpy does not try to complete in comments anymore.
+- The new command elpy-rpc-traceback gives access to the last stack
+  trace in the Elpy backend, helping with debugging problems.
+- The flymake check function is now run with the current directory as
+  / to avoid accidental imports.
+- Ensure correct handling of yas-snippet-dirs by Elpy. This variable
+  can be a string, so ensure it’s a list before adding to it.
+- The new variable elpy-show-installation-instructions can be used to
+  disable the installation screen.
+- Fix a very nasty bug causing spurious empty lines in a buffer or
+  consume 100% CPU in certain situations when using the Jedi backend.
+  Thanks to Matthias Dahl for finding this bug.
+- Various other bugfixes.
+
+New in Elpy 1.2.1
+=================
+
+Bugfix release.
+
+- The refactoring was not ported to the new asynchronous API,
+  resulting in an error when refactoring was attempted.
+- The project root now always returns a directory. Too many parts of
+  elpy relies on this. If the project root turns out to be your home
+  directory, elpy will warn you about it.
+- Elpy now works correctly with Emacs 24.2. There were some
+  compatibility functions missing.
+- Blocking RPC calls now do not block for one second even if there is
+  process output.
+
+New in Elpy 1.2
+===============
+
+- Elpy now uses asynchronous RPC. This means that Emacs should not
+  freeze anymore while eldoc or auto-complete functions run.
+- ``elpy-shell-send-region-or-buffer`` will now remove common
+  indentation of the region, making it possible to easily send parts
+  of an if statement or function body without manually adjusting the
+  indentation.
+- The Python package depends on ``flake8``, and will also try to be
+  smarter when detecting ``flake8`` for on-the-fly checking.
+- ``elpy-check`` can be run with a prefix argument to check the whole
+  project, instead of only the current file.
+- ``elpy-rgrep-symbol`` now ignores a few common directories
+  (``.tox``, ``build``, ``dist``).
+- When using the rope backend, Elpy will not create the
+  ``.ropeproject`` folders anymore. This should keep projects a lot
+  cleaner.
+
+New in Elpy 1.1
+===============
+
+- Elpy now always uses the root directory of the package as the
+  project root; this should avoid some confusion and improve
+  auto-completion suggestions
+- ``elpy-shell-send-region-or-buffer`` now accepts a prefix argument
+  to run code wrapped behind ``if __name__ == '__main__'``, which is
+  ignored by default
+- ``elpy-project-root`` is now a safe local variable and can be set
+  from file variables
+- Elpy now supports project-specific RPC processes, see
+  ``elpy-rpc-project-specific`` for how to use this
+- ``M-*`` now works to go back where you came from after a ``M-.``
+- Elpy now ships with a few dedicated snippets for YASnippet
+- Support and require Jedi 0.6.0
+
+New in Elpy 1.0
+===============
+
+- Version 0.9 was a release candidate, so this release focused on bug
+  fixes instead of new features.
+- ``elpy-enable`` now takes an optional argument that skips variable
+  initialization for those users who prefer their own defaults for
+  other modes.
+- ``python-check.sh`` has been removed from Elpy, as the flake8 tool
+  from pypi does everything it does, only better.
+- Elpy will now start the helper subprocess in the root directory,
+  avoiding accidental Python path clobbering.
+
+New in Elpy 0.9
+===============
+
+- Elpy now officially support Python 2.6, 2.7 and 3.3 on Emacs 24.2
+  and 24.3, with continuous integration tests thanks to
+  `Travis CI`_.
+- Extended support for Pydoc. ``C-u C-c C-d`` will now prompt for an
+  auto-completed symbol to run Pydoc on. The pydoc output will be
+  formatted and placed in a help buffer for easy review.
+- Refactoring support is back. ``C-c C-r`` will pop up a refactoring
+  wizard offering various refactoring options. Most of them depend on
+  the presence of Rope, though, even if Jedi is used as a completion
+  backend.
+- The Rope backend has been extended to provide completions for
+  modules in an import clause.
+- New refactoring option: Add missing imports. This will search for
+  undefined symbols in the current file and automatically add
+  appropriate imports.
+- ``C-c C-c (elpy-rgrep-symbol)`` now prompts for a regexp when a prefix
+  argument is given instead of using the symbol at point.
+
+.. _Travis CI: https://travis-ci.org/
+
+New in Elpy 0.8
+===============
+
+Python Backend Rewrite
+----------------------
+
+- Elpy does not use Pymacs, Ropemacs and Ropemode anymore, but instead
+  provides its own Python interface with the elpy package on PyPI.
+- This not only should improve performance, but also enables using
+  Jedi as an alternative backend for completion. Use ``M-x
+  elpy-set-backend`` to change between rope and jedi. For now, this
+  does disable all refactoring support, though.
+
+Project Support
+---------------
+
+- Elpy now has built-in project support. The interface is rather
+  simple: You can set ``elpy-project-root`` to the correct value in
+  ``.dir-locals.el``, or just rely on the automatic detection. If you
+  change your mind, you can always just ``elpy-set-project-root``.
+- New dependency: Find File in Project (ffip), bound to ``C-c C-f`` by
+  default. This will allow you to find files anywhere in your project
+  using a search-as-you-type interface like ido.
+- New dependency: nose, bound to ``C-c C-t`` by default. This will run
+  the nosetests binary in the root of your current library directory.
+  You can restrict the tests being run to the current test or the
+  current module by adding prefix arguments.
+- New function: Recursive grep for symbol, bound to ``C-c C-s`` by
+  default. This will search for the symbol at point in the whole
+  project.
+
+New dependencies
+----------------
+
+- idomenu, bound to ``C-c C-j`` by default. This replaces the standard
+  imenu interface with an ido-based search-as-you-type interface for
+  definitions in the current buffer.
+- virtualenv.el, replacing pyvirtualenv.el). Use ``M-x
+  virtualenv-workon`` to enable a virtualenv.
+- iedit.el, bound to ``M-,`` by default. This highlights all occurrences
+  of the symbol at point or the active region in the current buffer or
+  narrowing. When you edit any of them, all others will be edited the
+  same. This allows some basic and very quick refactoring.
+- New variable ``elpy-default-minor-modes`` which is run by ``elpy-mode``
+  on startup. If you don’t want to use some modes, remove them from
+  here.
+
+Key Bindings and Functions
+--------------------------
+
+- The key bindings have been reworked and cleaned up. Sorry, this
+  might cause confusion.
+- Yasnippet is now on its own keybinding, ``C-c C-i``, instead of
+  sharing the auto-complete interface. This was done because some
+  snippets conflicted with legitimate, unsnippy completions.
+- New function: Occur Definitions, bound to ``C-c C-o`` by default. This
+  will run the standard occur command to show definitions (classes and
+  functions) in your current buffer, giving you a very quick outline
+  and the ability to jump to different definitions quickly.
+- New function: Show Defun, bound to ``C-c C-q`` by default. This will
+  show the current method and possibly class in the mode line, which
+  is helpful in long functions.
+- New functions: Forward/backward definition, bound to ``M-n`` and ``M-p``
+  as well as ``<M-down>`` and ``<M-up>`` by default. These will jump to
+  the next or previous definition (class or function), helping with
+  quick navigation through a file.
+
+Miscellaneous
+-------------
+
+- The documentation function (``C-c C-d``) now uses pydoc when a prefix
+  arg is given.
+- The web search function (``C-c C-w``) now searches for the current
+  symbol by default. The tab-completing web documentation interface
+  was removed and is scheduled to be replaced with a new pydoc
+  interface in future versions.
+- The ``python-check.sh`` is now shipped with elpy. If you load elpy.el
+  before you load python.el, it should be the default
+  ``python-check-command``.

.emacs.d/elpa/elpy-20171206.847/elpy-autoloads.el

@@ -0,0 +1,51 @@
+;;; elpy-autoloads.el --- automatically extracted autoloads
+;;
+;;; Code:
+(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path))))
+
+;;;### (autoloads nil "elpy" "elpy.el" (23080 28380 123219 501000))
+;;; Generated autoloads from elpy.el
+
+(autoload 'elpy-enable "elpy" "\
+Enable Elpy in all future Python buffers.
+
+\(fn &optional IGNORED)" t nil)
+
+(autoload 'elpy-mode "elpy" "\
+Minor mode in Python buffers for the Emacs Lisp Python Environment.
+
+This mode fully supports virtualenvs. Once you switch a
+virtualenv using \\[pyvenv-workon], you can use
+\\[elpy-rpc-restart] to make the elpy Python process use your
+virtualenv.
+
+\\{elpy-mode-map}
+
+\(fn &optional ARG)" t nil)
+
+(autoload 'elpy-config "elpy" "\
+Configure Elpy.
+
+This function will pop up a configuration buffer, which is mostly
+a customize buffer, but has some more options.
+
+\(fn)" t nil)
+
+(autoload 'elpy-version "elpy" "\
+Display the version of Elpy.
+
+\(fn)" t nil)
+
+;;;***
+
+;;;### (autoloads nil nil ("elpy-django.el" "elpy-pkg.el" "elpy-profile.el"
+;;;;;;  "elpy-refactor.el" "elpy-shell.el") (23080 28381 456561 159000))
+
+;;;***
+
+;; Local Variables:
+;; version-control: never
+;; no-byte-compile: t
+;; no-update-autoloads: t
+;; End:
+;;; elpy-autoloads.el ends here

.emacs.d/elpa/elpy-20171206.847/elpy-django.el

@@ -0,0 +1,170 @@
+;;; elpy-django.el --- Django extension for elpy
+
+;; Copyright (C) 2013-2016  Jorgen Schaefer
+
+;; Author: Daniel Gopar <gopardaniel@gmail.com>
+;; URL: https://github.com/jorgenschaefer/elpy
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License
+;; as published by the Free Software Foundation; either version 3
+;; of the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This file serves as an extension to elpy by adding django support
+
+;;; Code:
+
+(require 's)
+
+;;;;;;;;;;;;;;;;;;;;;;
+;;; User customization
+
+(defcustom elpy-django-command "django-admin.py"
+  "Command to use when running Django specific commands.
+Best to set it to full path to 'manage.py' if it's available."
+  :type 'string
+  :safe 'stringp
+  :group 'elpy)
+(make-variable-buffer-local 'elpy-django-command)
+
+(defcustom elpy-django-server-ipaddr "127.0.0.1"
+  "What address Django will use when running the dev server."
+  :type 'string
+  :safe 'stringp
+  :group 'elpy)
+(make-variable-buffer-local 'elpy-django-server-ipaddr)
+
+(defcustom elpy-django-server-port "8000"
+  "What port Django will use when running the dev server."
+  :type 'string
+  :safe 'stringp
+  :group 'elpy)
+(make-variable-buffer-local 'elpy-django-server-port)
+
+(defcustom elpy-django-server-command "runserver"
+  "When executing `elpy-django-runserver' what should be the server
+command to use."
+  :type 'string
+  :safe 'stringp
+  :group 'elpy)
+(make-variable-buffer-local 'elpy-django-server-command)
+
+(defcustom elpy-django-always-prompt nil
+  "When non-nil, it will always prompt for extra arguments
+to pass with the chosen command."
+  :type 'boolean
+  :safe 'booleanp
+  :group 'elpy)
+(make-variable-buffer-local 'elpy-django-always-prompt)
+
+(defcustom elpy-django-commands-with-req-arg '("startapp" "startproject"
+                                               "loaddata" "sqlmigrate"
+                                               "sqlsequencereset"
+                                               "squashmigrations")
+  "Used to determine if we should prompt for arguments. Some commands
+require arguments in order for it to work."
+  :type 'list
+  :safe 'listp
+  :group 'elpy)
+(make-variable-buffer-local 'elpy-django-commands-with-req-arg)
+
+;;;;;;;;;;;;;;;;;;;;;;
+;; Key map
+
+(defvar elpy-django-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map (kbd "c") 'elpy-django-command)
+    (define-key map (kbd "r") 'elpy-django-runserver)
+    map)
+  "Key map for django extension")
+
+;;;;;;;;;;;;;;;;;;;;;;
+;;; Helper Functions
+
+(defun elpy-django-setup ()
+  "Decides whether to start the minor mode or not."
+  ;; Make sure we're in an actual file and we can find
+  ;; manage.py. Otherwise user will have to manually
+  ;; start this mode if they're using 'django-admin.py'
+  (when (locate-dominating-file default-directory "manage.py")
+    ;; Let's be nice and point to full path of 'manage.py'
+    ;; This only affects the buffer if there's no directory
+    ;; variable overwriting it.
+    (setq elpy-django-command
+          (concat (locate-dominating-file default-directory "manage.py") "manage.py"))
+    (elpy-django 1)))
+
+(defun elpy-django--get-commands ()
+  "Return list of django commands."
+  (let ((dj-commands-str nil)
+        (help-output
+         (shell-command-to-string (concat elpy-django-command " -h"))))
+    (setq dj-commands-str
+          (with-temp-buffer
+            (progn
+              (insert help-output)
+              (goto-char (point-min))
+              (delete-region (point) (search-forward "Available subcommands:" nil nil nil))
+              ;; cleanup [auth] and stuff
+              (goto-char (point-min))
+              (save-excursion
+                (replace-regexp "\\[.*\\]" ""))
+              (buffer-string))))
+    ;; get a list of commands from the output of manage.py -h
+    ;; What would be the pattern to optimize this ?
+    (setq dj-commands-str (split-string dj-commands-str "\n"))
+    (setq dj-commands-str (-remove (lambda (x) (string= x "")) dj-commands-str))
+    (setq dj-commands-str (mapcar (lambda (x) (s-trim x)) dj-commands-str))
+    (sort dj-commands-str 'string-lessp)))
+
+;;;;;;;;;;;;;;;;;;;;;;
+;;; User Functions
+
+(defun elpy-django-command (cmd)
+  "Prompt user for Django command. If called with `C-u',
+it will prompt for other flags/arguments to run."
+  (interactive (list (completing-read "Command: " (elpy-django--get-commands) nil nil)))
+  ;; Called with C-u, variable is set or is a cmd that requires an argument
+  (when (or current-prefix-arg
+            elpy-django-always-prompt
+            (member cmd elpy-django-commands-with-req-arg))
+    (setq cmd (concat cmd " " (read-shell-command (concat cmd ": ") "--noinput"))))
+  (compile (concat elpy-django-command " " cmd)))
+
+(defun elpy-django-runserver (arg)
+  "Start the server and automatically add the ipaddr and port.
+Also create it's own special buffer so that we can have multiple
+servers running per project.
+
+When called with a prefix (C-u), it will prompt for additional args."
+  (interactive "P")
+  (let* ((cmd (concat elpy-django-command " " elpy-django-server-command))
+         (proj-root (file-name-base (directory-file-name (elpy-project-root))))
+         (buff-name (format "*runserver[%s]*" proj-root)))
+    ;; Kill any previous instance of runserver since we might be doing something new
+    (when (get-buffer buff-name)
+      (kill-buffer buff-name))
+    (setq cmd (concat cmd " " elpy-django-server-ipaddr ":" elpy-django-server-port))
+    (when (or arg elpy-django-always-prompt)
+      (setq cmd (concat cmd " "(read-shell-command (concat cmd ": ")))))
+    (compile cmd)
+    (with-current-buffer "*compilation*"
+      (rename-buffer buff-name))))
+
+(define-minor-mode elpy-django
+  "Minor mode to for Django commands."
+  :group 'elpy)
+
+(provide 'elpy-django)
+;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+;;; elpy-django.el ends here

.emacs.d/elpa/elpy-20171206.847/elpy-pkg.el

@@ -0,0 +1,11 @@
+(define-package "elpy" "20171206.847" "Emacs Python Development Environment"
+  '((company "0.9.2")
+    (emacs "24.4")
+    (find-file-in-project "3.3")
+    (highlight-indentation "0.5.0")
+    (pyvenv "1.3")
+    (yasnippet "0.8.0")
+    (s "1.11.0")))
+;; Local Variables:
+;; no-byte-compile: t
+;; End:

.emacs.d/elpa/elpy-20171206.847/elpy-profile.el

@@ -0,0 +1,111 @@
+;;; elpy-profile.el --- Profiling capabilitiss for elpy
+
+;; Copyright (C) 2013-2016  Jorgen Schaefer
+
+;; Author: Gaby Launay <gaby.launay@tutanota.com>
+;; URL: https://github.com/jorgenschaefer/elpy
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License
+;; as published by the Free Software Foundation; either version 3
+;; of the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This file serves as an extension to elpy by adding profiling capabilities
+
+;;; Code:
+
+
+;;;;;;;;;;;;;;;;;;;;;;
+;;; User customization
+
+(defcustom elpy-profile-visualizer "snakeviz"
+  "Visualizer for elpy profile results."
+  :type 'str
+  :group 'elpy)
+
+;;;;;;;;;;;;;;;;;;;;;;
+;;; Helper Functions
+
+(defun elpy-profile--display-profiling (file)
+  "Display the profile result FILE using `elpy-profile-visualizer'."
+  (let ((exec (car (split-string elpy-profile-visualizer " " t)))
+        (args (append (cdr (split-string elpy-profile-visualizer " " t)) (list file))))
+    (if (executable-find exec)
+        (apply 'call-process exec nil 0 nil args)
+      (message "Elpy profile visualizer '%s' not found" exec))))
+
+(defun elpy-profile--sentinel (process string)
+  "Elpy profile sentinel."
+  (let ((filename (file-name-nondirectory (process-get process 'file)))
+        (prof-file (process-get process 'prof-file))
+        (dont-display (process-get process 'dont-display)))
+    (with-current-buffer "*elpy-profile-log*"
+      (view-mode))
+    (if (not (string-equal string "finished\n"))
+        (progn
+          (message  "[%s] Profiling failed" filename)
+          (display-buffer  "*elpy-profile-log*"))
+      (message  "[%s] Profiling succeeded" filename)
+      (when (not dont-display)
+        (elpy-profile--display-profiling prof-file)))))
+
+(defun elpy-profile--file (file &optional in-dir dont-display)
+  "Profile asynchronously FILE and display the result using
+`elpy-profile-visualizer'.
+
+If IN-DIR is non nil, profile result is saved in the same
+directory as the script.
+If DONT-DISPLAY is non nil, don't display the profile results."
+  (ignore-errors (kill-buffer "*elpy-profile-log*"))
+  (let* ((prof-file (if in-dir
+                        (concat (file-name-sans-extension file) ".profile")
+                      (concat (make-temp-file "elpy-profile-" nil ".profile"))))
+         (proc-name (format "elpy-profile-%s" file))
+         (proc-cmd (list python-shell-interpreter "-m" "cProfile" "-o" prof-file file))
+         (proc (make-process :name proc-name
+                             :buffer "*elpy-profile-log*"
+                             :sentinel 'elpy-profile--sentinel
+                             :command proc-cmd)))
+    (message "[%s] Profiling ..." (file-name-nondirectory file))
+    (process-put proc 'prof-file prof-file)
+    (process-put proc 'file file)
+    (process-put proc 'dont-display dont-display)
+    prof-file))
+
+;;;;;;;;;;;;;;;;;;;;;;
+;;; User Functions
+
+(defun elpy-profile-buffer-or-region (&optional in-dir dont-display)
+  "Profile asynchronously the active region or the current buffer
+and display the result using `elpy-profile-visualizer'.
+
+If IN-DIR is non nil, profile result is saved in the same
+directory as the script.
+If DONT-DISPLAY is non nil, don't display the profile results."
+  (interactive "P")
+  (let* ((file-name (buffer-name))
+         (file-dir (file-name-directory (buffer-file-name)))
+         (beg (if (region-active-p) (region-beginning) (point-min)))
+         (end (if (region-active-p) (region-end) (point-max)))
+         (tmp-file-prefix (if (region-active-p) "_region_" ""))
+         (tmp-file (if in-dir
+                       (concat file-dir "/" tmp-file-prefix file-name)
+                     (concat (make-temp-file "elpy-profile-" t)  "/" tmp-file-prefix file-name)))
+         (region (elpy-shell--region-without-indentation beg end)))
+    (with-temp-buffer
+      (insert region)
+      (write-region (point-min) (point-max) tmp-file nil t))
+    (elpy-profile--file tmp-file t dont-display)))
+
+(provide 'elpy-profile)
+;;; elpy-profile.el ends here

.emacs.d/elpa/elpy-20171206.847/elpy-refactor.el

@@ -0,0 +1,297 @@
+;;; elpy-refactor.el --- Refactoring mode for Elpy
+
+;; Copyright (C) 2013-2016  Jorgen Schaefer
+
+;; Author: Jorgen Schaefer <contact@jorgenschaefer.de>
+;; URL: https://github.com/jorgenschaefer/elpy
+
+;; This program is free software; you can redistribute it and/or
+;; modify it under the terms of the GNU General Public License
+;; as published by the Free Software Foundation; either version 3
+;; of the License, or (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This file provides an interface, including a major mode, to use
+;; refactoring options provided by the Rope library.
+
+;;; Code:
+
+;; We require elpy, but elpy loads us, so we shouldn't load it back.
+;; (require 'elpy)
+
+(defvar elpy-refactor-changes nil
+  "Changes that will be commited on \\[elpy-refactor-commit].")
+(make-variable-buffer-local 'elpy-refactor-current-changes)
+
+(defvar elpy-refactor-window-configuration nil
+  "The old window configuration. Will be restored after commit.")
+(make-variable-buffer-local 'elpy-refactor-window-configuration)
+
+(make-obsolete
+ 'elpy-refactor
+ "Refactoring has been unstable and flakey, support will be dropped in the future."
+ "elpy 1.5.0")
+(defun elpy-refactor ()
+  "Run the Elpy refactoring interface for Python code."
+  (interactive)
+  (save-some-buffers)
+  (let* ((selection (elpy-refactor-select
+                     (elpy-refactor-rpc-get-options)))
+         (method (car selection))
+         (args (cdr selection)))
+    (when method
+      (elpy-refactor-create-change-buffer
+       (elpy-refactor-rpc-get-changes method args)))))
+
+(defun elpy-refactor-select (options)
+  "Show the user the refactoring options and let her choose one.
+
+Depending on the chosen option, ask the user for further
+arguments and build the argument.
+
+Return a cons cell of the name of the option and the arg list
+created."
+  (let ((buf (get-buffer-create "*Elpy Refactor*"))
+        (pos (vector (1- (point))
+                     (ignore-errors
+                       (1- (region-beginning)))
+                     (ignore-errors
+                       (1- (region-end)))))
+        (inhibit-read-only t)
+        (options (sort options
+                       (lambda (a b)
+                         (let ((cata (cdr (assq 'category a)))
+                               (catb (cdr (assq 'category b))))
+                           (if (equal cata catb)
+                               (string< (cdr (assq 'description a))
+                                        (cdr (assq 'description b)))
+                             (string< cata catb))))))
+        (key ?a)
+        last-category
+        option-alist)
+    (with-current-buffer buf
+      (erase-buffer)
+      (dolist (option options)
+        (let ((category (cdr (assq 'category option)))
+              (description (cdr (assq 'description option)))
+              (name (cdr (assq 'name option)))
+              (args (cdr (assq 'args option))))
+          (when (not (equal category last-category))
+            (when last-category
+              (insert "\n"))
+            (insert (propertize category 'face 'bold) "\n")
+            (setq last-category category))
+          (insert " (" key ") " description "\n")
+          (setq option-alist (cons (list key name args)
+                                   option-alist))
+          (setq key (1+ key))))
+      (let ((window-conf (current-window-configuration)))
+        (unwind-protect
+            (progn
+              (with-selected-window (display-buffer buf)
+                (goto-char (point-min)))
+              (fit-window-to-buffer (get-buffer-window buf))
+              (let* ((key (read-key "Refactoring action? "))
+                     (entry (cdr (assoc key option-alist))))
+                (kill-buffer buf)
+                (cons (car entry)       ; name
+                      (elpy-refactor-build-arguments (cadr entry)
+                                                     pos))))
+          (set-window-configuration window-conf))))))
+
+(defun elpy-refactor-build-arguments (args pos)
+  "Translate an argument list specification to an argument list.
+
+POS is a vector of three elements, the current offset, the offset
+of the beginning of the region, and the offset of the end of the
+region.
+
+ARGS is a list of triples, each triple containing the name of an
+argument (ignored), the type of the argument, and a possible
+prompt string.
+
+Available types:
+
+  offset       - The offset in the buffer, (1- (point))
+  start_offset - Offset of the beginning of the region
+  end_offset   - Offset of the end of the region
+  string       - A free-form string
+  filename     - A non-existing file name
+  directory    - An existing directory name
+  boolean      - A boolean question"
+  (mapcar (lambda (arg)
+            (let ((type (cadr arg))
+                  (prompt (caddr arg)))
+              (cond
+               ((equal type "offset")
+                (aref pos 0))
+               ((equal type "start_offset")
+                (aref pos 1))
+               ((equal type "end_offset")
+                (aref pos 2))
+               ((equal type "string")
+                (read-from-minibuffer prompt))
+               ((equal type "filename")
+                (expand-file-name
+                 (read-file-name prompt)))
+               ((equal type "directory")
+                (expand-file-name
+                 (read-directory-name prompt)))
+               ((equal type "boolean")
+                (y-or-n-p prompt)))))
+          args))
+
+(defun elpy-refactor-create-change-buffer (changes)
+  "Show the user a buffer of changes.
+
+The user can review the changes and confirm them with
+\\[elpy-refactor-commit]."
+  (when (not changes)
+    (error "No changes for this refactoring action."))
+  (with-current-buffer (get-buffer-create "*Elpy Refactor*")
+    (elpy-refactor-mode)
+    (setq elpy-refactor-changes changes
+          elpy-refactor-window-configuration (current-window-configuration))
+    (let ((inhibit-read-only t))
+      (erase-buffer)
+      (elpy-refactor-insert-changes changes))
+    (select-window (display-buffer (current-buffer)))
+    (goto-char (point-min))))
+
+(defun elpy-refactor-insert-changes (changes)
+  "Format and display the changes described in CHANGES."
+  (insert (propertize "Use C-c C-c to apply the following changes."
+                      'face 'bold)
+          "\n\n")
+  (dolist (change changes)
+    (let ((action (cdr (assq 'action change))))
+      (cond
+       ((equal action "change")
+        (insert (cdr (assq 'diff change))
+                "\n"))
+       ((equal action "create")
+        (let ((type (cdr (assq 'type change))))
+          (if (equal type "file")
+              (insert "+++ " (cdr (assq 'file change)) "\n"
+                      "Create file " (cdr (assq 'file change)) "\n"
+                      "\n")
+            (insert "+++ " (cdr (assq 'path change)) "\n"
+                    "Create directory " (cdr (assq 'path change)) "\n"
+                    "\n"))))
+       ((equal action "move")
+        (insert "--- " (cdr (assq 'source change)) "\n"
+                "+++ " (cdr (assq 'destination change)) "\n"
+                "Rename " (cdr (assq 'type change)) "\n"
+                "\n"))
+       ((equal action "delete")
+        (let ((type (cdr (assq 'type change))))
+          (if (equal type "file")
+              (insert "--- " (cdr (assq 'file change)) "\n"
+                      "Delete file " (cdr (assq 'file change)) "\n"
+                      "\n")
+            (insert "--- " (cdr (assq 'path change)) "\n"
+                    "Delete directory " (cdr (assq 'path change)) "\n"
+                    "\n"))))))))
+
+(defvar elpy-refactor-mode-map
+  (let ((map (make-sparse-keymap)))
+    (define-key map (kbd "C-c C-c") 'elpy-refactor-commit)
+    (define-key map (kbd "q") 'bury-buffer)
+    (define-key map (kbd "h") 'describe-mode)
+    (define-key map (kbd "?") 'describe-mode)
+    map)
+  "The key map for `elpy-refactor-mode'.")
+
+(define-derived-mode elpy-refactor-mode diff-mode "Elpy Refactor"
+  "Mode to display refactoring actions and ask confirmation from the user.
+
+\\{elpy-refactor-mode-map}"
+  :group 'elpy
+  (view-mode 1))
+
+(defun elpy-refactor-commit ()
+  "Commit the changes in the current buffer."
+  (interactive)
+  (when (not elpy-refactor-changes)
+    (error "No changes to commit."))
+  ;; Restore the window configuration as the first thing so that
+  ;; changes below are visible to the user. Especially the point
+  ;; change in possible buffer changes.
+  (set-window-configuration elpy-refactor-window-configuration)
+  (dolist (change elpy-refactor-changes)
+    (let ((action (cdr (assq 'action change))))
+      (cond
+       ((equal action "change")
+        (with-current-buffer (find-file-noselect (cdr (assq 'file change)))
+          ;; This would break for save-excursion as the buffer is
+          ;; truncated, so all markets now point to position 1.
+          (let ((old-point (point)))
+            (undo-boundary)
+            (erase-buffer)
+            (insert (cdr (assq 'contents change)))
+            (undo-boundary)
+            (goto-char old-point))))
+       ((equal action "create")
+        (if (equal (cdr (assq 'type change))
+                   "file")
+            (find-file-noselect (cdr (assq 'file change)))
+          (make-directory (cdr (assq 'path change)))))
+       ((equal action "move")
+        (let* ((source (cdr (assq 'source change)))
+               (dest (cdr (assq 'destination change)))
+               (buf (get-file-buffer source)))
+          (when buf
+            (with-current-buffer buf
+              (setq buffer-file-name dest)
+              (rename-buffer (file-name-nondirectory dest) t)))
+          (rename-file source dest)))
+       ((equal action "delete")
+        (if (equal (cdr (assq 'type change)) "file")
+            (let ((name (cdr (assq 'file change))))
+              (when (y-or-n-p (format "Really delete %s? " name))
+                (delete-file name t)))
+          (let ((name (cdr (assq 'directory change))))
+            (when (y-or-n-p (format "Really delete %s? " name))
+              (delete-directory name nil t))))))))
+  (kill-buffer (current-buffer)))
+
+(defun elpy-refactor-rpc-get-options ()
+  "Get a list of refactoring options from the Elpy RPC."
+  (if (use-region-p)
+      (elpy-rpc "get_refactor_options"
+                (list (buffer-file-name)
+                      (1- (region-beginning))
+                      (1- (region-end))))
+    (elpy-rpc "get_refactor_options"
+              (list (buffer-file-name)
+                    (1- (point))))))
+
+(defun elpy-refactor-rpc-get-changes (method args)
+  "Get a list of changes from the Elpy RPC after applying METHOD with ARGS."
+  (elpy-rpc "refactor"
+            (list (buffer-file-name)
+                  method args)))
+
+(defun elpy-refactor-options (option)
+  "Show available refactor options and let user choose one."
+  (interactive "c[i]: importmagic-fixup [p]: autopep8-fix-code [r]: refactor")
+  (let ((choice (char-to-string option)))
+    (cond
+     ((string-equal choice "i")
+      (elpy-importmagic-fixup))
+     ((string-equal choice "p")
+      (elpy-autopep8-fix-code))
+     ((string-equal choice "r")
+      (elpy-refactor)))))
+
+(provide 'elpy-refactor)
+;;; elpy-refactor.el ends here

.emacs.d/elpa/elpy-20171206.847/elpy/__init__.py

@@ -0,0 +1,41 @@
+# Elpy, the Emacs Lisp Python Environment
+
+# Copyright (C) 2013-2016 Jorgen Schaefer
+
+# Author: Jorgen Schaefer <contact@jorgenschaefer.de>
+# URL: http://github.com/jorgenschaefer/elpy
+
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# as published by the Free Software Foundation; either version 3
+# of the License, or (at your option) any later version.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with this program. If not, see <http://www.gnu.org/licenses/>.
+
+"""The Emacs Lisp Python Environment.
+
+Elpy is a mode for Emacs to support writing Python code. This package
+provides the backend within Python to support auto-completion,
+documentation extraction, and navigation.
+
+Emacs will start the protocol by running the module itself, like so:
+
+  python -m elpy
+
+This will emit a greeting string on a single line, and then wait for
+the protocol to start. Details of the protocol can be found in
+elpy.rpc.
+
+This package is unlikely to be useful on its own.
+
+"""
+
+__author__ = "Jorgen Schaefer"
+__version__ = "1.17.0"
+__license__ = "GPL"

.emacs.d/elpa/elpy-20171206.847/elpy/__main__.py

@@ -0,0 +1,25 @@
+"""Main interface to the RPC server.
+
+You should be able to just run the following to use this module:
+
+python -m elpy
+
+The first line should be "elpy-rpc ready". If it isn't, something
+broke.
+
+"""
+
+import os
+import sys
+
+import elpy
+from elpy.server import ElpyRPCServer
+
+if __name__ == '__main__':
+    stdin = sys.stdin
+    stdout = sys.stdout
+    sys.stdout = sys.stderr = open(os.devnull, "w")
+    stdout.write('elpy-rpc ready ({0})\n'
+                 .format(elpy.__version__))
+    stdout.flush()
+    ElpyRPCServer(stdin, stdout).serve_forever()

.emacs.d/elpa/elpy-20171206.847/elpy/auto_pep8.py

@@ -0,0 +1,21 @@
+"""Glue for the "autopep8" library.
+
+"""
+
+from elpy.rpc import Fault
+
+
+try:
+    import autopep8
+except ImportError:  # pragma: no cover
+    autopep8 = None
+
+
+def fix_code(code):
+    """Formats Python code to conform to the PEP 8 style guide.
+
+    """
+    if not autopep8:
+        raise Fault('autopep8 not installed, cannot fix code.',
+                    code=400)
+    return autopep8.fix_code(code, apply_config=True)

.emacs.d/elpa/elpy-20171206.847/elpy/compat.py

@@ -0,0 +1,33 @@
+"""Python 2/3 compatibility definitions.
+
+These are used by the rest of Elpy to keep compatibility definitions
+in one place.
+
+"""
+
+import sys
+
+
+if sys.version_info >= (3, 0):
+    PYTHON3 = True
+
+    from io import StringIO
+
+    def ensure_not_unicode(obj):
+        return obj
+else:
+    PYTHON3 = False
+
+    from StringIO import StringIO  # noqa
+
+    def ensure_not_unicode(obj):
+        """Return obj. If it's a unicode string, convert it to str first.
+
+        Pydoc functions simply don't find anything for unicode
+        strings. No idea why.
+
+        """
+        if isinstance(obj, unicode):
+            return obj.encode("utf-8")
+        else:
+            return obj

.emacs.d/elpa/elpy-20171206.847/elpy/impmagic.py

@@ -0,0 +1,118 @@
+"""Glue for the "importmagic" library.
+
+"""
+
+import os
+import sys
+import threading
+
+
+try:
+    import importmagic.index
+    import importmagic.symbols
+    import importmagic.importer
+except ImportError:  # pragma: no cover
+    importmagic = None
+
+
+class ImportMagicError(Exception):
+    """Used to pass defined errors from importmagic to the RPC layer."""
+
+
+class ImportMagic(object):
+
+    def __init__(self):
+        self.is_enabled = bool(importmagic)
+        # fail_message is reported to the user when symbol_index
+        # is (still) None
+        self.fail_message = "symbol index is not yet ready"
+        self.project_root = None
+        self.symbol_index = None
+        self.favorites = set()
+        self._thread = None
+
+    def _build_symbol_index(self, project_root, custom_path, blacklist_re):
+        try:
+            index = importmagic.index.SymbolIndex(blacklist_re=blacklist_re)
+            if os.environ.get('ELPY_TEST'):
+                # test suite support: do not index the whole PYTHONPATH, it
+                # takes much too long
+                index.build_index([])
+            elif custom_path:
+                index.build_index(custom_path)
+            else:
+                index.build_index([project_root] + sys.path)
+        except Exception as e:
+            self.fail_message = "symbol index failed to build: %s" % e
+        else:
+            self.symbol_index = index
+
+    def build_index(self, project_root, custom_path=None, blacklist_re=None):
+        self.project_root = None
+        self._thread = threading.Thread(target=self._build_symbol_index,
+                                        args=(project_root, custom_path,
+                                              blacklist_re))
+        self._thread.setDaemon(True)
+        self._thread.start()
+
+    def get_import_symbols(self, symbol):
+        scores = self.symbol_index.symbol_scores(symbol)
+
+        def sort_key(item):
+            score, mod, var = item
+            if mod in self.favorites:
+                return 2 + score, mod, var
+            return score, mod, var
+
+        scores.sort(key=sort_key, reverse=True)
+        return ["from %s import %s" % (mod, var) if var else "import %s" % mod
+                for (_, mod, var) in scores]
+
+    def add_import(self, source, statement):
+        imports = importmagic.importer.Imports(self.symbol_index, source)
+        if statement.startswith('import '):
+            sepalias = None
+            alias = None
+            if ' as ' in statement:
+                sepalias = statement.find(' as ')
+                alias = statement[sepalias+4:]
+            modname = statement[7:sepalias]
+            imports.add_import(modname, alias)
+            self.favorites.add(modname)
+        else:
+            sep = statement.find(' import ')
+            sepalias = None
+            alias = None
+            if ' as ' in statement:
+                sepalias = statement.find(' as ')
+                alias = statement[sepalias+4:]
+            modname = statement[5:sep]
+            name = statement[sep+8:sepalias]
+            if sep > -1:
+                self.favorites.add(modname)
+                imports.add_import_from(modname, name, alias)
+        start_line, end_line, import_block = imports.get_update()
+        return start_line, end_line, import_block
+
+    def get_unresolved_symbols(self, source):
+        try:
+            scope = importmagic.symbols.Scope.from_source(source)
+        except SyntaxError:
+            raise ImportMagicError('cannot find unresolved names in '
+                                   'incomplete file')
+        unres, unref = scope.find_unresolved_and_unreferenced_symbols()
+        return list(unres)
+
+    def remove_unreferenced_imports(self, source):
+        try:
+            scope = importmagic.symbols.Scope.from_source(source)
+        except SyntaxError:
+            raise ImportMagicError('cannot find unreferenced imports in '
+                                   'incomplete file')
+        unres, unref = scope.find_unresolved_and_unreferenced_symbols()
+        # Note: we do not supply "unres" to the call below, since we do
+        # not want to add imports without querying the user from which
+        # module symbols should be imported.
+        start_line, end_line, import_block = importmagic.importer.get_update(
+            source, self.symbol_index, set(), unref)
+        return start_line, end_line, import_block

.emacs.d/elpa/elpy-20171206.847/elpy/jedibackend.py

@@ -0,0 +1,397 @@
+"""Elpy backend using the Jedi library.
+
+This backend uses the Jedi library:
+
+https://github.com/davidhalter/jedi
+
+"""
+
+import sys
+import traceback
+
+import jedi
+
+from elpy import rpc
+
+
+class JediBackend(object):
+    """The Jedi backend class.
+
+    Implements the RPC calls we can pass on to Jedi.
+
+    Documentation: http://jedi.jedidjah.ch/en/latest/docs/plugin-api.html
+
+    """
+    name = "jedi"
+
+    def __init__(self, project_root):
+        self.project_root = project_root
+        self.completions = {}
+        sys.path.append(project_root)
+
+    def rpc_get_completions(self, filename, source, offset):
+        line, column = pos_to_linecol(source, offset)
+        proposals = run_with_debug(jedi, 'completions',
+                                   source=source, line=line, column=column,
+                                   path=filename, encoding='utf-8')
+        if proposals is None:
+            return []
+        self.completions = dict((proposal.name, proposal)
+                                for proposal in proposals)
+        return [{'name': proposal.name.rstrip("="),
+                 'suffix': proposal.complete.rstrip("="),
+                 'annotation': proposal.type,
+                 'meta': proposal.description}
+                for proposal in proposals]
+
+    def rpc_get_completion_docstring(self, completion):
+        proposal = self.completions.get(completion)
+        if proposal is None:
+            return None
+        else:
+            return proposal.docstring(fast=False)
+
+    def rpc_get_completion_location(self, completion):
+        proposal = self.completions.get(completion)
+        if proposal is None:
+            return None
+        else:
+            return (proposal.module_path, proposal.line)
+
+    def rpc_get_docstring(self, filename, source, offset):
+        line, column = pos_to_linecol(source, offset)
+        locations = run_with_debug(jedi, 'goto_definitions',
+                                   source=source, line=line, column=column,
+                                   path=filename, encoding='utf-8')
+        if locations and locations[-1].docstring():
+            return ('Documentation for {0}:\n\n'.format(
+                locations[-1].full_name) + locations[-1].docstring())
+        else:
+            return None
+
+    def rpc_get_definition(self, filename, source, offset):
+        line, column = pos_to_linecol(source, offset)
+        locations = run_with_debug(jedi, 'goto_definitions',
+                                   source=source, line=line, column=column,
+                                   path=filename, encoding='utf-8')
+        # goto_definitions() can return silly stuff like __builtin__
+        # for int variables, so we fall back on goto() in those
+        # cases. See issue #76.
+        if (
+                locations and
+                locations[0].module_path is None
+        ):
+            locations = run_with_debug(jedi, 'goto_assignments',
+                                       source=source, line=line,
+                                       column=column,
+                                       path=filename, encoding='utf-8')
+        if not locations:
+            return None
+        else:
+            loc = locations[-1]
+            try:
+                if loc.module_path:
+                    if loc.module_path == filename:
+                        offset = linecol_to_pos(source,
+                                                loc.line,
+                                                loc.column)
+                    else:
+                        with open(loc.module_path) as f:
+                            offset = linecol_to_pos(f.read(),
+                                                    loc.line,
+                                                    loc.column)
+                else:
+                    return None
+            except IOError:
+                return None
+            return (loc.module_path, offset)
+
+    def rpc_get_assignment(self, filename, source, offset):
+        line, column = pos_to_linecol(source, offset)
+        locations = run_with_debug(jedi, 'goto_assignments',
+                                   source=source, line=line, column=column,
+                                   path=filename, encoding='utf-8')
+        if not locations:
+            return None
+        else:
+            loc = locations[-1]
+            try:
+                if loc.module_path:
+                    if loc.module_path == filename:
+                        offset = linecol_to_pos(source,
+                                                loc.line,
+                                                loc.column)
+                    else:
+                        with open(loc.module_path) as f:
+                            offset = linecol_to_pos(f.read(),
+                                                    loc.line,
+                                                    loc.column)
+                else:
+                    return None
+            except IOError:
+                return None
+            return (loc.module_path, offset)
+
+    def rpc_get_calltip(self, filename, source, offset):
+        line, column = pos_to_linecol(source, offset)
+        calls = run_with_debug(jedi, 'call_signatures',
+                               source=source, line=line, column=column,
+                               path=filename, encoding='utf-8')
+        if calls:
+            call = calls[0]
+        else:
+            call = None
+        if not call:
+            return None
+        try:
+            call.index
+        except AttributeError as e:
+            if "get_definition" in str(e):
+                # Bug #627 / jedi#573
+                return None
+            elif "get_subscope_by_name" in str(e):
+                # Bug #677 / jedi#628
+                return None
+            else:
+                raise
+        return {"name": call.name,
+                "index": call.index,
+                "params": [param.description for param in call.params]}
+
+    def rpc_get_usages(self, filename, source, offset):
+        """Return the uses of the symbol at offset.
+
+        Returns a list of occurrences of the symbol, as dicts with the
+        fields name, filename, and offset.
+
+        """
+        line, column = pos_to_linecol(source, offset)
+        uses = run_with_debug(jedi, 'usages',
+                              source=source, line=line, column=column,
+                              path=filename, encoding='utf-8')
+        if uses is None:
+            return None
+        result = []
+        for use in uses:
+            if use.module_path == filename:
+                offset = linecol_to_pos(source, use.line, use.column)
+            elif use.module_path is not None:
+                with open(use.module_path) as f:
+                    text = f.read()
+                offset = linecol_to_pos(text, use.line, use.column)
+
+            result.append({"name": use.name,
+                           "filename": use.module_path,
+                           "offset": offset})
+
+        return result
+
+    def rpc_get_names(self, filename, source, offset):
+        """Return the list of possible names"""
+        # Remove form feed characters, they confuse Jedi (jedi#424)
+        source = source.replace("\f", " ")
+        names = jedi.api.names(source=source,
+                               path=filename, encoding='utf-8',
+                               all_scopes=True,
+                               definitions=True,
+                               references=True)
+
+        result = []
+        for name in names:
+            if name.module_path == filename:
+                offset = linecol_to_pos(source, name.line, name.column)
+            elif name.module_path is not None:
+                with open(name.module_path) as f:
+                    text = f.read()
+                offset = linecol_to_pos(text, name.line, name.column)
+            result.append({"name": name.name,
+                           "filename": name.module_path,
+                           "offset": offset})
+        return result
+
+
+# From the Jedi documentation:
+#
+#   line is the current line you want to perform actions on (starting
+#   with line #1 as the first line). column represents the current
+#   column/indent of the cursor (starting with zero). source_path
+#   should be the path of your file in the file system.
+
+def pos_to_linecol(text, pos):
+    """Return a tuple of line and column for offset pos in text.
+
+    Lines are one-based, columns zero-based.
+
+    This is how Jedi wants it. Don't ask me why.
+
+    """
+    line_start = text.rfind("\n", 0, pos) + 1
+    line = text.count("\n", 0, line_start) + 1
+    col = pos - line_start
+    return line, col
+
+
+def linecol_to_pos(text, line, col):
+    """Return the offset of this line and column in text.
+
+    Lines are one-based, columns zero-based.
+
+    This is how Jedi wants it. Don't ask me why.
+
+    """
+    nth_newline_offset = 0
+    for i in range(line - 1):
+        new_offset = text.find("\n", nth_newline_offset)
+        if new_offset < 0:
+            raise ValueError("Text does not have {0} lines."
+                             .format(line))
+        nth_newline_offset = new_offset + 1
+    offset = nth_newline_offset + col
+    if offset > len(text):
+        raise ValueError("Line {0} column {1} is not within the text"
+                         .format(line, col))
+    return offset
+
+
+def run_with_debug(jedi, name, *args, **kwargs):
+    re_raise = kwargs.pop('re_raise', ())
+    # Remove form feed characters, they confuse Jedi (jedi#424)
+    if 'source' in kwargs:
+        kwargs['source'] = kwargs['source'].replace("\f", " ")
+    try:
+        script = jedi.Script(*args, **kwargs)
+        return getattr(script, name)()
+    except Exception as e:
+        if isinstance(e, re_raise):
+            raise
+        # Bug jedi#417
+        if isinstance(e, TypeError) and str(e) == 'no dicts allowed':
+            return None
+        # Bug jedi#427
+        if isinstance(e, UnicodeDecodeError):
+            return None
+        # Bug jedi#429
+        if isinstance(e, IndexError):
+            return None
+        # Bug jedi#431
+        if isinstance(e, AttributeError) and str(e).endswith("'end_pos'"):
+            return None
+        # Bug in Python 2.6, see #275
+        if isinstance(e, OSError) and e.errno == 13:
+            return None
+        # Bug jedi#466
+        if (
+                isinstance(e, SyntaxError) and
+                "EOL while scanning string literal" in str(e)
+        ):
+            return None
+        # Bug jedi#482
+        if isinstance(e, UnicodeEncodeError):
+            return None
+        # Bug jedi#485
+        if (
+                isinstance(e, ValueError) and
+                "invalid \\x escape" in str(e)
+        ):
+            return None
+        # Bug jedi#485 in Python 3
+        if (
+                isinstance(e, SyntaxError) and
+                "truncated \\xXX escape" in str(e)
+        ):
+            return None
+        # Bug jedi#465
+        if (
+                isinstance(e, SyntaxError) and
+                "encoding declaration in Unicode string" in str(e)
+        ):
+            return None
+        # Bug #337 / jedi#471
+        if (
+                isinstance(e, ImportError) and
+                "No module named" in str(e)
+        ):
+            return None
+        # Bug #365 / jedi#486 - fixed in Jedi 0.8.2
+        if (
+                isinstance(e, UnboundLocalError) and
+                "local variable 'path' referenced before assignment" in str(e)
+        ):
+            return None
+        # Bug #366 / jedi#491
+        if (
+                isinstance(e, ValueError) and
+                "__loader__ is None" in str(e)
+        ):
+            return None
+        # Bug #353
+        if (
+                isinstance(e, OSError) and
+                "No such file or directory" in str(e)
+        ):
+            return None
+        # Bug #561, #564, #570, #588, #593, #599 / jedi#572, jedi#579, jedi#590
+        if isinstance(e, KeyError):
+            return None
+        # Bug #519 / jedi#610
+        if (
+                isinstance(e, RuntimeError) and
+                "maximum recursion depth exceeded" in str(e)
+        ):
+            return None
+        # Bug #563 / jedi#589
+        if (
+                isinstance(e, AttributeError) and
+                "MergedNamesDict" in str(e)
+        ):
+            return None
+        # Bug #615 / jedi#592
+        if (
+                isinstance(e, AttributeError) and
+                "ListComprehension" in str(e)
+        ):
+            return None
+        # Bug #569 / jedi#593
+        if (
+                isinstance(e, AttributeError) and
+                "names_dict" in str(e)
+        ):
+            return None
+
+        from jedi import debug
+
+        debug_info = []
+
+        def _debug(level, str_out):
+            if level == debug.NOTICE:
+                prefix = "[N]"
+            elif level == debug.WARNING:
+                prefix = "[W]"
+            else:
+                prefix = "[?]"
+            debug_info.append(u"{0} {1}".format(prefix, str_out))
+
+        jedi.set_debug_function(_debug, speed=False)
+        try:
+            script = jedi.Script(*args, **kwargs)
+            return getattr(script, name)()
+        except Exception as e:
+            source = kwargs.get('source')
+            sc_args = []
+            sc_args.extend(repr(arg) for arg in args)
+            sc_args.extend("{0}={1}".format(k, "source" if k == "source"
+                                            else repr(v))
+                           for (k, v) in kwargs.items())
+
+            data = {
+                "traceback": traceback.format_exc(),
+                "jedi_debug_info": {'script_args': ", ".join(sc_args),
+                                    'source': source,
+                                    'method': name,
+                                    'debug_info': debug_info}
+            }
+            raise rpc.Fault(message=str(e),
+                            code=500,
+                            data=data)
+        finally:
+            jedi.set_debug_function(None)

.emacs.d/elpa/elpy-20171206.847/elpy/pydocutils.py

@@ -0,0 +1,91 @@
+import sys
+import types
+
+from pydoc import safeimport, resolve, ErrorDuringImport
+from pkgutil import iter_modules
+
+from elpy import compat
+
+# Types we want to recurse into (nodes).
+CONTAINER_TYPES = (type, types.ModuleType)
+# Types of attributes we can get documentation for (leaves).
+PYDOC_TYPES = (type,
+               types.FunctionType,
+               types.BuiltinFunctionType,
+               types.BuiltinMethodType,
+               types.MethodType,
+               types.ModuleType)
+if not compat.PYTHON3:  # pragma: nocover
+    # Python 2 old style classes
+    CONTAINER_TYPES = tuple(list(CONTAINER_TYPES) + [types.ClassType])
+    PYDOC_TYPES = tuple(list(PYDOC_TYPES) + [types.ClassType])
+
+
+def get_pydoc_completions(modulename):
+    """Get possible completions for modulename for pydoc.
+
+    Returns a list of possible values to be passed to pydoc.
+
+    """
+    modulename = compat.ensure_not_unicode(modulename)
+    modulename = modulename.rstrip(".")
+    if modulename == "":
+        return sorted(get_modules())
+    candidates = get_completions(modulename)
+    if candidates:
+        return sorted(candidates)
+    needle = modulename
+    if "." in needle:
+        modulename, part = needle.rsplit(".", 1)
+        candidates = get_completions(modulename)
+    else:
+        candidates = get_modules()
+    return sorted(candidate for candidate in candidates
+                  if candidate.startswith(needle))
+
+
+def get_completions(modulename):
+    modules = set("{0}.{1}".format(modulename, module)
+                  for module in get_modules(modulename))
+
+    try:
+        module, name = resolve(modulename)
+    except ImportError:
+        return modules
+    if isinstance(module, CONTAINER_TYPES):
+        modules.update("{0}.{1}".format(modulename, name)
+                       for name in dir(module)
+                       if not name.startswith("_") and
+                       isinstance(getattr(module, name),
+                                  PYDOC_TYPES))
+    return modules
+
+
+def get_modules(modulename=None):
+    """Return a list of modules and packages under modulename.
+
+    If modulename is not given, return a list of all top level modules
+    and packages.
+
+    """
+    modulename = compat.ensure_not_unicode(modulename)
+    if not modulename:
+        try:
+            return ([modname for (importer, modname, ispkg)
+                     in iter_modules()
+                     if not modname.startswith("_")] +
+                    list(sys.builtin_module_names))
+        except OSError:
+            # Bug in Python 2.6, see #275
+            return list(sys.builtin_module_names)
+    try:
+        module = safeimport(modulename)
+    except ErrorDuringImport:
+        return []
+    if module is None:
+        return []
+    if hasattr(module, "__path__"):
+        return [modname for (importer, modname, ispkg)
+                in iter_modules(module.__path__)
+                if not modname.startswith("_")]
+    return []

.emacs.d/elpa/elpy-20171206.847/elpy/refactor.py

@@ -0,0 +1,381 @@
+"""Refactoring methods for elpy.
+
+This interfaces directly with rope, regardless of the backend used,
+because the other backends don't really offer refactoring choices.
+Once Jedi is similarly featureful as Rope we can try and offer both.
+
+
+# Too complex:
+
+- Restructure: Interesting, but too complex, and needs deep Rope
+  knowledge to do well.
+
+- ChangeSignature: Slightly less complex interface, but still to
+  complex, requiring a large effort for the benefit.
+
+
+# Too useless:
+
+I could not get these to work in any useful fashion. I might be doing
+something wrong.
+
+- ExtractVariable does not replace the code extracted with the
+  variable, making it a glorified copy&paste function. Emacs can do
+  better than this interface by itself.
+
+- EncapsulateField: Getter/setter methods are outdated, this should be
+  using properties.
+
+- IntroduceFactory: Inserts a trivial method to the current class.
+  Cute.
+
+- IntroduceParameter: Introduces a parameter correctly, but does not
+  replace the old code with the parameter. So it just edits the
+  argument list and adds a shiny default.
+
+- LocalToField: Seems to just add "self." in front of all occurrences
+  of a variable in the local scope.
+
+- MethodObject: This turns the current method into a callable
+  class/object. Not sure what that would be good for.
+
+
+# Can't even get to work:
+
+- ImportOrganizer expand_star_imports, handle_long_imports,
+  relatives_to_absolutes: Seem not to do anything.
+
+- create_move: I was not able to figure out what it would like to see
+  as its attrib argument.
+
+"""
+
+import os
+
+from elpy.rpc import Fault
+
+try:
+    from rope.base.exceptions import RefactoringError
+    from rope.base.project import Project
+    from rope.base.libutils import path_to_resource
+    from rope.base import change as rope_change
+    from rope.base import worder
+    from rope.refactor.importutils import ImportOrganizer
+    from rope.refactor.topackage import ModuleToPackage
+    from rope.refactor.rename import Rename
+    from rope.refactor.move import create_move
+    from rope.refactor.inline import create_inline
+    from rope.refactor.extract import ExtractMethod
+    from rope.refactor.usefunction import UseFunction
+    ROPE_AVAILABLE = True
+except ImportError:
+    ROPE_AVAILABLE = False
+
+
+def options(description, **kwargs):
+    """Decorator to set some options on a method."""
+    def set_notes(function):
+        function.refactor_notes = {'name': function.__name__,
+                                   'category': "Miscellaneous",
+                                   'description': description,
+                                   'doc': getattr(function, '__doc__',
+                                                  ''),
+                                   'args': []}
+        function.refactor_notes.update(kwargs)
+        return function
+    return set_notes
+
+
+class Refactor(object):
+    """The main refactoring interface.
+
+    Once initialized, the first call should be to get_refactor_options
+    to get a list of refactoring options at a given position. The
+    returned value will also list any additional options required.
+
+    Once you picked one, you can call get_changes to get the actual
+    refactoring changes.
+
+    """
+    def __init__(self, project_root, filename):
+        self.project_root = project_root
+        if not ROPE_AVAILABLE:
+            raise Fault('rope not installed, cannot refactor code.',
+                        code=400)
+        if not os.path.exists(project_root):
+            raise Fault(
+                "cannot do refactoring without a local project root",
+                code=400
+            )
+        self.project = Project(project_root, ropefolder=None)
+        self.resource = path_to_resource(self.project, filename)
+
+    def get_refactor_options(self, start, end=None):
+        """Return a list of options for refactoring at the given position.
+
+        If `end` is also given, refactoring on a region is assumed.
+
+        Each option is a dictionary of key/value pairs. The value of
+        the key 'name' is the one to be used for get_changes.
+
+        The key 'args' contains a list of additional arguments
+        required for get_changes.
+
+        """
+        result = []
+        for symbol in dir(self):
+            if not symbol.startswith("refactor_"):
+                continue
+            method = getattr(self, symbol)
+            if not method.refactor_notes.get('available', True):
+                continue
+            category = method.refactor_notes['category']
+            if end is not None and category != 'Region':
+                continue
+            if end is None and category == 'Region':
+                continue
+            is_on_symbol = self._is_on_symbol(start)
+            if not is_on_symbol and category in ('Symbol', 'Method'):
+                continue
+            requires_import = method.refactor_notes.get('only_on_imports',
+                                                        False)
+            if requires_import and not self._is_on_import_statement(start):
+                continue
+            result.append(method.refactor_notes)
+        return result
+
+    def _is_on_import_statement(self, offset):
+        "Does this offset point to an import statement?"
+        data = self.resource.read()
+        bol = data.rfind("\n", 0, offset) + 1
+        eol = data.find("\n", 0, bol)
+        if eol == -1:
+            eol = len(data)
+        line = data[bol:eol]
+        line = line.strip()
+        if line.startswith("import ") or line.startswith("from "):
+            return True
+        else:
+            return False
+
+    def _is_on_symbol(self, offset):
+        "Is this offset on a symbol?"
+        if not ROPE_AVAILABLE:
+            return False
+        data = self.resource.read()
+        if offset >= len(data):
+            return False
+        if data[offset] != '_' and not data[offset].isalnum():
+            return False
+        word = worder.get_name_at(self.resource, offset)
+        if word:
+            return True
+        else:
+            return False
+
+    def get_changes(self, name, *args):
+        """Return a list of changes for the named refactoring action.
+
+        Changes are dictionaries describing a single action to be
+        taken for the refactoring to be successful.
+
+        A change has an action and possibly a type. In the description
+        below, the action is before the slash and the type after it.
+
+        change: Change file contents
+        - file: The path to the file to change
+        - contents: The new contents for the file
+        - Diff: A unified diff showing the changes introduced
+
+        create/file: Create a new file
+        - file: The file to create
+
+        create/directory: Create a new directory
+        - path: The directory to create
+
+        move/file: Rename a file
+        - source: The path to the source file
+        - destination: The path to the destination file name
+
+        move/directory: Rename a directory
+        - source: The path to the source directory
+        - destination: The path to the destination directory name
+
+        delete/file: Delete a file
+        - file: The file to delete
+
+        delete/directory: Delete a directory
+        - path: The directory to delete
+
+        """
+        if not name.startswith("refactor_"):
+            raise ValueError("Bad refactoring name {0}".format(name))
+        method = getattr(self, name)
+        if not method.refactor_notes.get('available', True):
+            raise RuntimeError("Method not available")
+        return method(*args)
+
+    @options("Convert from x import y to import x.y as y", category="Imports",
+             args=[("offset", "offset", None)],
+             only_on_imports=True,
+             available=ROPE_AVAILABLE)
+    def refactor_froms_to_imports(self, offset):
+        """Converting imports of the form "from ..." to "import ..."."""
+        refactor = ImportOrganizer(self.project)
+        changes = refactor.froms_to_imports(self.resource, offset)
+        return translate_changes(changes)
+
+    @options("Reorganize and clean up", category="Imports",
+             available=ROPE_AVAILABLE)
+    def refactor_organize_imports(self):
+        """Clean up and organize imports."""
+        refactor = ImportOrganizer(self.project)
+        changes = refactor.organize_imports(self.resource)
+        return translate_changes(changes)
+
+    @options("Convert the current module into a package", category="Module",
+             available=ROPE_AVAILABLE)
+    def refactor_module_to_package(self):
+        """Convert the current module into a package."""
+        refactor = ModuleToPackage(self.project, self.resource)
+        return self._get_changes(refactor)
+
+    @options("Rename symbol at point", category="Symbol",
+             args=[("offset", "offset", None),
+                   ("new_name", "string", "Rename to: "),
+                   ("in_hierarchy", "boolean",
+                    "Rename in super-/subclasses as well? "),
+                   ("docs", "boolean",
+                    "Replace occurences in docs and strings? ")
+                   ],
+             available=ROPE_AVAILABLE)
+    def refactor_rename_at_point(self, offset, new_name, in_hierarchy, docs):
+        """Rename the symbol at point."""
+        try:
+            refactor = Rename(self.project, self.resource, offset)
+        except RefactoringError as e:
+            raise Fault(str(e), code=400)
+        return self._get_changes(refactor, new_name,
+                                 in_hierarchy=in_hierarchy, docs=docs)
+
+    @options("Rename current module", category="Module",
+             args=[("new_name", "string", "Rename to: ")],
+             available=ROPE_AVAILABLE)
+    def refactor_rename_current_module(self, new_name):
+        """Rename the current module."""
+        refactor = Rename(self.project, self.resource, None)
+        return self._get_changes(refactor, new_name)
+
+    @options("Move the current module to a different package",
+             category="Module",
+             args=[("new_name", "directory", "Destination package: ")],
+             available=ROPE_AVAILABLE)
+    def refactor_move_module(self, new_name):
+        """Move the current module."""
+        refactor = create_move(self.project, self.resource)
+        resource = path_to_resource(self.project, new_name)
+        return self._get_changes(refactor, resource)
+
+    @options("Inline function call at point", category="Symbol",
+             args=[("offset", "offset", None),
+                   ("only_this", "boolean", "Only this occurrence? ")],
+             available=ROPE_AVAILABLE)
+    def refactor_create_inline(self, offset, only_this):
+        """Inline the function call at point."""
+        refactor = create_inline(self.project, self.resource, offset)
+        if only_this:
+            return self._get_changes(refactor, remove=False, only_current=True)
+        else:
+            return self._get_changes(refactor, remove=True, only_current=False)
+
+    @options("Extract current region as a method", category="Region",
+             args=[("start", "start_offset", None),
+                   ("end", "end_offset", None),
+                   ("name", "string", "Method name: "),
+                   ("make_global", "boolean", "Create global method? ")],
+             available=ROPE_AVAILABLE)
+    def refactor_extract_method(self, start, end, name,
+                                make_global):
+        """Extract region as a method."""
+        refactor = ExtractMethod(self.project, self.resource, start, end)
+        return self._get_changes(
+            refactor, name, similar=True, global_=make_global
+        )
+
+    @options("Use the function at point wherever possible", category="Method",
+             args=[("offset", "offset", None)],
+             available=ROPE_AVAILABLE)
+    def refactor_use_function(self, offset):
+        """Use the function at point wherever possible."""
+        try:
+            refactor = UseFunction(self.project, self.resource, offset)
+        except RefactoringError as e:
+            raise Fault(
+                'Refactoring error: {}'.format(e),
+                code=400
+            )
+        return self._get_changes(refactor)
+
+    def _get_changes(self, refactor, *args, **kwargs):
+        try:
+            changes = refactor.get_changes(*args, **kwargs)
+        except Exception as e:
+            raise Fault("Error during refactoring: {}".format(e),
+                        code=400)
+        return translate_changes(changes)
+
+
+def translate_changes(initial_change):
+    """Translate rope.base.change.Change instances to dictionaries.
+
+    See Refactor.get_changes for an explanation of the resulting
+    dictionary.
+
+    """
+    agenda = [initial_change]
+    result = []
+    while agenda:
+        change = agenda.pop(0)
+        if isinstance(change, rope_change.ChangeSet):
+            agenda.extend(change.changes)
+        elif isinstance(change, rope_change.ChangeContents):
+            result.append({'action': 'change',
+                           'file': change.resource.real_path,
+                           'contents': change.new_contents,
+                           'diff': change.get_description()})
+        elif isinstance(change, rope_change.CreateFile):
+            result.append({'action': 'create',
+                           'type': 'file',
+                           'file': change.resource.real_path})
+        elif isinstance(change, rope_change.CreateFolder):
+            result.append({'action': 'create',
+                           'type': 'directory',
+                           'path': change.resource.real_path})
+        elif isinstance(change, rope_change.MoveResource):
+            result.append({'action': 'move',
+                           'type': ('directory'
+                                    if change.new_resource.is_folder()
+                                    else 'file'),
+                           'source': change.resource.real_path,
+                           'destination': change.new_resource.real_path})
+        elif isinstance(change, rope_change.RemoveResource):
+            if change.resource.is_folder():
+                result.append({'action': 'delete',
+                               'type': 'directory',
+                               'path': change.resource.real_path})
+            else:
+                result.append({'action': 'delete',
+                               'type': 'file',
+                               'file': change.resource.real_path})
+    return result
+
+
+class FakeResource(object):
+    """A fake resource in case Rope is absence."""
+
+    def __init__(self, filename):
+        self.real_path = filename
+
+    def read(self):
+        with open(self.real_path) as f:
+            return f.read()

.emacs.d/elpa/elpy-20171206.847/elpy/ropebackend.py

@@ -0,0 +1,290 @@
+"""Elpy backend using the Rope library.
+
+This backend uses the Rope library:
+
+http://rope.sourceforge.net/
+
+"""
+
+import os
+import time
+
+import rope.contrib.codeassist
+import rope.base.project
+import rope.base.libutils
+import rope.base.exceptions
+import rope.contrib.findit
+
+from elpy import rpc
+import elpy.pydocutils
+
+VALIDATE_EVERY_SECONDS = 5
+MAXFIXES = 5
+
+
+class RopeBackend(object):
+    """The Rope backend class.
+
+    Implements the RPC calls we can pass on to Rope. Also subclasses
+    the native backend to provide methods Rope does not provide, if
+    any.
+
+    """
+    name = "rope"
+
+    def __init__(self, project_root):
+        super(RopeBackend, self).__init__()
+        self.last_validation = 0
+        if not os.path.exists(project_root):
+            raise rpc.Fault(
+                "rope does not support files without a local project root",
+                code=400
+            )
+        self.project_root = project_root
+        self.completions = {}
+        prefs = dict(ignored_resources=['*.pyc', '*~', '.ropeproject',
+                                        '.hg', '.svn', '_svn', '.git'],
+                     python_files=['*.py'],
+                     save_objectdb=False,
+                     compress_objectdb=False,
+                     automatic_soa=True,
+                     soa_followed_calls=0,
+                     perform_doa=True,
+                     validate_objectdb=True,
+                     max_history_items=32,
+                     save_history=False,
+                     compress_history=False,
+                     indent_size=4,
+                     extension_modules=[],
+                     import_dynload_stdmods=True,
+                     ignore_syntax_errors=False,
+                     ignore_bad_imports=False)
+        self.project = rope.base.project.Project(self.project_root,
+                                                 ropefolder=None,
+                                                 **prefs)
+
+    def get_resource(self, filename):
+        if filename is not None and os.path.exists(filename):
+            return rope.base.libutils.path_to_resource(self.project,
+                                                       filename,
+                                                       'file')
+        else:
+            return None
+
+    def validate(self):
+        """Validate the stored project.
+
+        This should be called before every use of Rope. It will
+        revalidate the project, but do some call throttling.
+
+        """
+        now = time.time()
+        if now > self.last_validation + VALIDATE_EVERY_SECONDS:
+            try:
+                self.project.validate()
+            except rope.base.exceptions.ResourceNotFoundError:
+                pass
+            self.last_validation = now
+
+    def call_rope(self, rope_function, filename, source, offset,
+                  **kwargs):
+        self.validate()
+        resource = self.get_resource(filename)
+        try:
+            return rope_function(self.project,
+                                 source, offset,
+                                 resource,
+                                 maxfixes=MAXFIXES,
+                                 **kwargs)
+        except Exception:
+            return None
+
+    def rpc_get_completions(self, filename, source, offset):
+        proposals = self.call_rope(
+            rope.contrib.codeassist.code_assist,
+            filename, source, offset
+        )
+        if proposals is None:
+            return []
+        try:
+            starting_offset = rope.contrib.codeassist.starting_offset(source,
+                                                                      offset)
+        except Exception:
+            return []
+        prefixlen = offset - starting_offset
+        try:
+            self.completions = dict((proposal.name, proposal)
+                                    for proposal in proposals)
+            return [{'name': proposal.name,
+                     'suffix': proposal.name[prefixlen:],
+                     'annotation': proposal.type,
+                     'meta': str(proposal)}
+                    for proposal in proposals]
+        except Exception:
+            return []
+
+    def rpc_get_completion_docstring(self, completion):
+        proposal = self.completions.get(completion)
+        if proposal is None:
+            return None
+        else:
+            return proposal.get_doc()
+
+    def rpc_get_completion_location(self, completion):
+        proposal = self.completions.get(completion)
+        if proposal is None:
+            return None
+        else:
+            if not proposal.pyname:
+                return None
+            module, lineno = proposal.pyname.get_definition_location()
+            if module is None:
+                return None
+            resource = module.get_module().get_resource()
+            return (resource.real_path, lineno)
+
+    def rpc_get_definition(self, filename, source, offset):
+        location = self.call_rope(
+            rope.contrib.findit.find_definition,
+            filename, source, offset
+        )
+        if location is None:
+            return None
+        else:
+            return (location.resource.real_path, location.offset)
+
+    def rpc_get_calltip(self, filename, source, offset):
+        offset = find_called_name_offset(source, offset)
+        if 0 < offset < len(source) and source[offset] == ')':
+            offset -= 1
+
+        calltip = self.call_rope(
+            rope.contrib.codeassist.get_calltip,
+            filename, source, offset,
+            remove_self=True
+        )
+        if calltip is None:
+            return None
+
+        calltip = calltip.replace(".__init__(", "(")
+        calltip = calltip.replace("(self)", "()")
+        calltip = calltip.replace("(self, ", "(")
+        # "elpy.tests.support.source_and_offset(source)"
+        # =>
+        # "support.source_and_offset(source)"
+        try:
+            openpos = calltip.index("(")
+            period2 = calltip.rindex(".", 0, openpos)
+            period1 = calltip.rindex(".", 0, period2)
+            calltip = calltip[period1 + 1:]
+        except ValueError:
+            pass
+        return calltip
+
+    def rpc_get_docstring(self, filename, source, offset):
+        return self.call_rope(
+            rope.contrib.codeassist.get_doc,
+            filename, source, offset
+        )
+
+
+def find_called_name_offset(source, orig_offset):
+    """Return the offset of a calling function.
+
+    This only approximates movement.
+
+    """
+    offset = min(orig_offset, len(source) - 1)
+    paren_count = 0
+    while True:
+        if offset <= 1:
+            return orig_offset
+        elif source[offset] == '(':
+            if paren_count == 0:
+                return offset - 1
+            else:
+                paren_count -= 1
+        elif source[offset] == ')':
+            paren_count += 1
+        offset -= 1
+
+
+##################################################################
+# A recurring problem in Rope for Elpy is that it searches the whole
+# project root for Python files. If the user edits a file in their
+# home directory, this can easily read a whole lot of files, making
+# Rope practically useless. We change the file finding algorithm here
+# to only recurse into directories with an __init__.py file in them.
+def find_source_folders(self, folder):
+    for resource in folder.get_folders():
+        if self._is_package(resource):
+            return [folder]
+    result = []
+    for resource in folder.get_files():
+        if resource.name.endswith('.py'):
+            result.append(folder)
+            break
+    for resource in folder.get_folders():
+        if self._is_package(resource):
+            result.append(resource)
+    return result
+
+import rope.base.pycore
+rope.base.pycore.PyCore._find_source_folders = find_source_folders
+
+
+def get_files(self):
+    if self.files is None:
+        self.files = get_python_project_files(self.project)
+    return self.files
+
+rope.base.project._FileListCacher.get_files = get_files
+
+
+def get_python_project_files(project):
+    for dirname, subdirs, files in os.walk(project.root.real_path):
+        for filename in files:
+            yield rope.base.libutils.path_to_resource(
+                project, os.path.join(dirname, filename), 'file')
+            subdirs[:] = [subdir for subdir in subdirs
+                          if os.path.exists(os.path.join(dirname, subdir,
+                                                         "__init__.py"))]
+
+
+##################################################################
+# Monkey patching a method in rope because it doesn't complete import
+# statements.
+
+orig_code_completions = (rope.contrib.codeassist.
+                         _PythonCodeAssist._code_completions)
+
+
+def code_completions(self):
+    proposals = get_import_completions(self)
+    if proposals:
+        return proposals
+    else:
+        return orig_code_completions(self)
+
+
+def get_import_completions(self):
+    if not self.word_finder.is_import_statement(self.offset):
+        return []
+    modulename = self.word_finder.get_primary_at(self.offset)
+    # Rope can handle modules in packages
+    if "." in modulename:
+        return []
+    return dict((name, FakeProposal(name))
+                for name in elpy.pydocutils.get_modules()
+                if name.startswith(modulename))
+
+
+class FakeProposal(object):
+    def __init__(self, name):
+        self.name = name
+        self.type = "mock"
+
+    def get_doc(self):
+        return None
+
+rope.contrib.codeassist._PythonCodeAssist._code_completions = code_completions

.emacs.d/elpa/elpy-20171206.847/elpy/rpc.py

@@ -0,0 +1,151 @@
+"""A simple JSON-RPC-like server.
+
+The server will read and write lines of JSON-encoded method calls and
+responses.
+
+See the documentation of the JSONRPCServer class for further details.
+
+"""
+
+import json
+import sys
+import traceback
+
+
+class JSONRPCServer(object):
+    """Simple JSON-RPC-like server.
+
+    This class will read single-line JSON expressions from stdin,
+    decode them, and pass them to a handler. Return values from the
+    handler will be JSON-encoded and written to stdout.
+
+    To implement a handler, you need to subclass this class and add
+    methods starting with "rpc_". Methods then will be found.
+
+    Method calls should be encoded like this:
+
+    {"id": 23, "method": "method_name", "params": ["foo", "bar"]}
+
+    This will call self.rpc_method("foo", "bar").
+
+    Responses will be encoded like this:
+
+    {"id": 23, "result": "foo"}
+
+    Errors will be encoded like this:
+
+    {"id": 23, "error": "Simple error message"}
+
+    See http://www.jsonrpc.org/ for the inspiration of the protocol.
+
+    """
+
+    def __init__(self, stdin=None, stdout=None):
+        """Return a new JSON-RPC server object.
+
+        It will read lines of JSON data from stdin, and write the
+        responses to stdout.
+
+        """
+        if stdin is None:
+            self.stdin = sys.stdin
+        else:
+            self.stdin = stdin
+        if stdout is None:
+            self.stdout = sys.stdout
+        else:
+            self.stdout = stdout
+
+    def read_json(self):
+        """Read a single line and decode it as JSON.
+
+        Can raise an EOFError() when the input source was closed.
+
+        """
+        line = self.stdin.readline()
+        if line == '':
+            raise EOFError()
+        return json.loads(line)
+
+    def write_json(self, **kwargs):
+        """Write an JSON object on a single line.
+
+        The keyword arguments are interpreted as a single JSON object.
+        It's not possible with this method to write non-objects.
+
+        """
+        self.stdout.write(json.dumps(kwargs) + "\n")
+        self.stdout.flush()
+
+    def handle_request(self):
+        """Handle a single JSON-RPC request.
+
+        Read a request, call the appropriate handler method, and
+        return the encoded result. Errors in the handler method are
+        caught and encoded as error objects. Errors in the decoding
+        phase are not caught, as we can not respond with an error
+        response to them.
+
+        """
+        request = self.read_json()
+        if 'method' not in request:
+            raise ValueError("Received a bad request: {0}"
+                             .format(request))
+        method_name = request['method']
+        request_id = request.get('id', None)
+        params = request.get('params') or []
+        try:
+            method = getattr(self, "rpc_" + method_name, None)
+            if method is not None:
+                result = method(*params)
+            else:
+                result = self.handle(method_name, params)
+            if request_id is not None:
+                self.write_json(result=result,
+                                id=request_id)
+        except Fault as fault:
+            error = {"message": fault.message,
+                     "code": fault.code}
+            if fault.data is not None:
+                error["data"] = fault.data
+            self.write_json(error=error, id=request_id)
+        except Exception as e:
+            error = {"message": str(e),
+                     "code": 500,
+                     "data": {"traceback": traceback.format_exc()}}
+            self.write_json(error=error, id=request_id)
+
+    def handle(self, method_name, args):
+        """Handle the call to method_name.
+
+        You should overwrite this method in a subclass.
+        """
+        raise Fault("Unknown method {0}".format(method_name))
+
+    def serve_forever(self):
+        """Serve requests forever.
+
+        Errors are not caught, so this is a slight misnomer.
+
+        """
+        while True:
+            try:
+                self.handle_request()
+            except (KeyboardInterrupt, EOFError, SystemExit):
+                break
+
+
+class Fault(Exception):
+    """RPC Fault instances.
+
+    code defines the severity of the warning.
+
+    2xx: Normal behavior lead to end of operation, i.e. a warning
+    4xx: An expected error occurred
+    5xx: An unexpected error occurred (usually includes a traceback)
+    """
+    def __init__(self, message, code=500, data=None):
+        super(Fault, self).__init__(message)
+        self.message = message
+        self.code = code
+        self.data = data

.emacs.d/elpa/elpy-20171206.847/elpy/server.py

@@ -0,0 +1,322 @@
+"""Method implementations for the Elpy JSON-RPC server.
+
+This file implements the methods exported by the JSON-RPC server. It
+handles backend selection and passes methods on to the selected
+backend.
+
+"""
+import io
+import os
+import pydoc
+
+from elpy.pydocutils import get_pydoc_completions
+from elpy.rpc import JSONRPCServer, Fault
+from elpy.impmagic import ImportMagic, ImportMagicError
+from elpy.auto_pep8 import fix_code
+from elpy.yapfutil import fix_code as fix_code_with_yapf
+
+
+try:
+    from elpy import jedibackend
+except ImportError:  # pragma: no cover
+    jedibackend = None
+
+try:
+    from elpy import ropebackend
+except ImportError:  # pragma: no cover
+    ropebackend = None
+
+
+class ElpyRPCServer(JSONRPCServer):
+    """The RPC server for elpy.
+
+    See the rpc_* methods for exported method documentation.
+
+    """
+    def __init__(self, *args, **kwargs):
+        super(ElpyRPCServer, self).__init__(*args, **kwargs)
+        self.backend = None
+        self.import_magic = ImportMagic()
+        self.project_root = None
+
+    def _call_backend(self, method, default, *args, **kwargs):
+        """Call the backend method with args.
+
+        If there is currently no backend, return default."""
+        meth = getattr(self.backend, method, None)
+        if meth is None:
+            return default
+        else:
+            return meth(*args, **kwargs)
+
+    def rpc_echo(self, *args):
+        """Return the arguments.
+
+        This is a simple test method to see if the protocol is
+        working.
+
+        """
+        return args
+
+    def rpc_init(self, options):
+        self.project_root = options["project_root"]
+
+        if self.import_magic.is_enabled:
+            self.import_magic.build_index(self.project_root)
+
+        if ropebackend and options["backend"] == "rope":
+            self.backend = ropebackend.RopeBackend(self.project_root)
+        elif jedibackend and options["backend"] == "jedi":
+            self.backend = jedibackend.JediBackend(self.project_root)
+        elif ropebackend:
+            self.backend = ropebackend.RopeBackend(self.project_root)
+        elif jedibackend:
+            self.backend = jedibackend.JediBackend(self.project_root)
+        else:
+            self.backend = None
+
+        return {
+            'backend': (self.backend.name if self.backend is not None
+                        else None)
+        }
+
+    def rpc_get_calltip(self, filename, source, offset):
+        """Get the calltip for the function at the offset.
+
+        """
+        return self._call_backend("rpc_get_calltip", None, filename,
+                                  get_source(source), offset)
+
+    def rpc_get_completions(self, filename, source, offset):
+        """Get a list of completion candidates for the symbol at offset.
+
+        """
+        results = self._call_backend("rpc_get_completions", [], filename,
+                                     get_source(source), offset)
+        # Uniquify by name
+        results = list(dict((res['name'], res) for res in results)
+                       .values())
+        results.sort(key=lambda cand: _pysymbol_key(cand["name"]))
+        return results
+
+    def rpc_get_completion_docstring(self, completion):
+        """Return documentation for a previously returned completion.
+
+        """
+        return self._call_backend("rpc_get_completion_docstring",
+                                  None, completion)
+
+    def rpc_get_completion_location(self, completion):
+        """Return the location for a previously returned completion.
+
+        This returns a list of [file name, line number].
+
+        """
+        return self._call_backend("rpc_get_completion_location", None,
+                                  completion)
+
+    def rpc_get_definition(self, filename, source, offset):
+        """Get the location of the definition for the symbol at the offset.
+
+        """
+        return self._call_backend("rpc_get_definition", None, filename,
+                                  get_source(source), offset)
+
+    def rpc_get_assignment(self, filename, source, offset):
+        """Get the location of the assignment for the symbol at the offset.
+
+        """
+        return self._call_backend("rpc_get_assignment", None, filename,
+                                  get_source(source), offset)
+
+    def rpc_get_docstring(self, filename, source, offset):
+        """Get the docstring for the symbol at the offset.
+
+        """
+        return self._call_backend("rpc_get_docstring", None, filename,
+                                  get_source(source), offset)
+
+    def rpc_get_pydoc_completions(self, name=None):
+        """Return a list of possible strings to pass to pydoc.
+
+        If name is given, the strings are under name. If not, top
+        level modules are returned.
+
+        """
+        return get_pydoc_completions(name)
+
+    def rpc_get_pydoc_documentation(self, symbol):
+        """Get the Pydoc documentation for the given symbol.
+
+        Uses pydoc and can return a string with backspace characters
+        for bold highlighting.
+
+        """
+        try:
+            docstring = pydoc.render_doc(str(symbol),
+                                         "Elpy Pydoc Documentation for %s",
+                                         False)
+        except (ImportError, pydoc.ErrorDuringImport):
+            return None
+        else:
+            if isinstance(docstring, bytes):
+                docstring = docstring.decode("utf-8", "replace")
+            return docstring
+
+    def rpc_get_refactor_options(self, filename, start, end=None):
+        """Return a list of possible refactoring options.
+
+        This list will be filtered depending on whether it's
+        applicable at the point START and possibly the region between
+        START and END.
+
+        """
+        try:
+            from elpy import refactor
+        except:
+            raise ImportError("Rope not installed, refactorings unavailable")
+        ref = refactor.Refactor(self.project_root, filename)
+        return ref.get_refactor_options(start, end)
+
+    def rpc_refactor(self, filename, method, args):
+        """Return a list of changes from the refactoring action.
+
+        A change is a dictionary describing the change. See
+        elpy.refactor.translate_changes for a description.
+
+        """
+        try:
+            from elpy import refactor
+        except:
+            raise ImportError("Rope not installed, refactorings unavailable")
+        if args is None:
+            args = ()
+        ref = refactor.Refactor(self.project_root, filename)
+        return ref.get_changes(method, *args)
+
+    def rpc_get_usages(self, filename, source, offset):
+        """Get usages for the symbol at point.
+
+        """
+        source = get_source(source)
+        if hasattr(self.backend, "rpc_get_usages"):
+            return self.backend.rpc_get_usages(filename, source, offset)
+        else:
+            raise Fault("get_usages not implemented by current backend",
+                        code=400)
+
+    def rpc_get_names(self, filename, source, offset):
+        """Get all possible names
+
+        """
+        source = get_source(source)
+        if hasattr(self.backend, "rpc_get_names"):
+            return self.backend.rpc_get_names(filename, source, offset)
+        else:
+            raise Fault("get_names not implemented by current backend",
+                        code=400)
+
+    def _ensure_import_magic(self):  # pragma: no cover
+        if not self.import_magic.is_enabled:
+            raise Fault("fixup_imports not enabled; install importmagic module",
+                        code=400)
+        if not self.import_magic.symbol_index:
+            raise Fault(self.import_magic.fail_message, code=200)  # XXX code?
+
+    def rpc_get_import_symbols(self, filename, source, symbol):
+        """Return a list of modules from which the given symbol can be imported.
+
+        """
+        self._ensure_import_magic()
+        try:
+            return self.import_magic.get_import_symbols(symbol)
+        except ImportMagicError as err:
+            raise Fault(str(err), code=200)
+
+    def rpc_add_import(self, filename, source, statement):
+        """Add an import statement to the module.
+
+        """
+        self._ensure_import_magic()
+        source = get_source(source)
+        try:
+            return self.import_magic.add_import(source, statement)
+        except ImportMagicError as err:
+            raise Fault(str(err), code=200)
+
+    def rpc_get_unresolved_symbols(self, filename, source):
+        """Return a list of unreferenced symbols in the module.
+
+        """
+        self._ensure_import_magic()
+        source = get_source(source)
+        try:
+            return self.import_magic.get_unresolved_symbols(source)
+        except ImportMagicError as err:
+            raise Fault(str(err), code=200)
+
+    def rpc_remove_unreferenced_imports(self, filename, source):
+        """Remove unused import statements.
+
+        """
+        self._ensure_import_magic()
+        source = get_source(source)
+        try:
+            return self.import_magic.remove_unreferenced_imports(source)
+        except ImportMagicError as err:
+            raise Fault(str(err), code=200)
+
+    def rpc_fix_code(self, source):
+        """Formats Python code to conform to the PEP 8 style guide.
+
+        """
+        source = get_source(source)
+        return fix_code(source)
+
+    def rpc_fix_code_with_yapf(self, source):
+        """Formats Python code to conform to the PEP 8 style guide.
+
+        """
+        source = get_source(source)
+        return fix_code_with_yapf(source)
+
+
+def get_source(fileobj):
+    """Translate fileobj into file contents.
+
+    fileobj is either a string or a dict. If it's a string, that's the
+    file contents. If it's a string, then the filename key contains
+    the name of the file whose contents we are to use.
+
+    If the dict contains a true value for the key delete_after_use,
+    the file should be deleted once read.
+
+    """
+    if not isinstance(fileobj, dict):
+        return fileobj
+    else:
+        try:
+            with io.open(fileobj["filename"], encoding="utf-8",
+                         errors="ignore") as f:
+                return f.read()
+        finally:
+            if fileobj.get('delete_after_use'):
+                try:
+                    os.remove(fileobj["filename"])
+                except:  # pragma: no cover
+                    pass
+
+
+def _pysymbol_key(name):
+    """Return a sortable key index for name.
+
+    Sorting is case-insensitive, with the first underscore counting as
+    worse than any character, but subsequent underscores do not. This
+    means that dunder symbols (like __init__) are sorted after symbols
+    that start with an alphabetic character, but before those that
+    start with only a single underscore.
+
+    """
+    if name.startswith("_"):
+        name = "~" + name[1:]
+    return name.lower()

.emacs.d/elpa/elpy-20171206.847/elpy/tests/__init__.py

@@ -0,0 +1,8 @@
+"""Unit tests for elpy."""
+
+try:
+    import unittest2
+    import sys
+    sys.modules['unittest'] = unittest2
+except:
+    pass

.emacs.d/elpa/elpy-20171206.847/elpy/tests/compat.py

@@ -0,0 +1,18 @@
+"""Python 2/3 compatibility definitions.
+
+These are used by the rest of Elpy to keep compatibility definitions
+in one place.
+
+"""
+
+import sys
+
+
+if sys.version_info >= (3, 0):
+    PYTHON3 = True
+    import builtins
+    from io import StringIO
+else:
+    PYTHON3 = False
+    import __builtin__ as builtins  # noqa
+    from StringIO import StringIO  # noqa

.emacs.d/elpa/elpy-20171206.847/elpy/tests/support.py

@@ -0,0 +1,950 @@
+# coding: utf-8
+
+"""Support classes and functions for the elpy test code.
+
+Elpy uses a bit of a peculiar test setup to avoid redundancy. For the
+tests of the two backends, we provide generic test cases for generic
+tests and for specific callback tests.
+
+These mixins can be included in the actual test classes. We can't add
+these tests to a BackendTestCase subclass directly because the test
+discovery would find them there and try to run them, which would fail.
+
+"""
+
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+
+from elpy.tests import compat
+
+
+class BackendTestCase(unittest.TestCase):
+    """Base class for backend tests.
+
+    This class sets up a project root directory and provides an easy
+    way to create files within the project root.
+
+    """
+
+    def setUp(self):
+        """Create the project root and make sure it gets cleaned up."""
+        super(BackendTestCase, self).setUp()
+        self.project_root = tempfile.mkdtemp(prefix="elpy-test")
+        self.addCleanup(shutil.rmtree, self.project_root, True)
+
+    def project_file(self, relname, contents):
+        """Create a file named relname within the project root.
+
+        Write contents into that file.
+
+        """
+        full_name = os.path.join(self.project_root, relname)
+        try:
+            os.makedirs(os.path.dirname(full_name))
+        except OSError:
+            pass
+        if compat.PYTHON3:
+            fobj = open(full_name, "w", encoding="utf-8")
+        else:
+            fobj = open(full_name, "w")
+        with fobj as f:
+            f.write(contents)
+        return full_name
+
+
+class GenericRPCTests(object):
+    """Generic RPC test methods.
+
+    This is a mixin to add tests that should be run for all RPC
+    methods that follow the generic (filename, source, offset) calling
+    conventions.
+
+    """
+    METHOD = None
+
+    def rpc(self, filename, source, offset):
+        method = getattr(self.backend, self.METHOD)
+        return method(filename, source, offset)
+
+    def test_should_not_fail_on_inexisting_file(self):
+        filename = self.project_root + "/doesnotexist.py"
+        self.rpc(filename, "", 0)
+
+    def test_should_not_fail_on_empty_file(self):
+        filename = self.project_file("test.py", "")
+        self.rpc(filename, "", 0)
+
+    def test_should_not_fail_if_file_is_none(self):
+        self.rpc(None, "", 0)
+
+    def test_should_not_fail_for_module_syntax_errors(self):
+        source, offset = source_and_offset(
+            "class Foo(object):\n"
+            "  def bar(self):\n"
+            "    foo(_|_"
+            "    bar("
+            "\n"
+            "  def a(self):\n"
+            "    pass\n"
+            "\n"
+            "  def b(self):\n"
+            "  pass\n"
+            "\n"
+            "  def b(self):\n"
+            "  pass\n"
+            "\n"
+            "  def b(self):\n"
+            "  pass\n"
+            "\n"
+            "  def b(self):\n"
+            "  pass\n"
+            "\n"
+            "  def b(self):\n"
+            "  pass\n"
+        )
+        filename = self.project_file("test.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_for_bad_indentation(self):
+        # Bug in Rope: rope#80
+        source, offset = source_and_offset(
+            "def foo():\n"
+            "       print(23)_|_\n"
+            "      print(17)\n")
+        filename = self.project_file("test.py", source)
+
+        self.rpc(filename, source, offset)
+
+    @unittest.skipIf((3, 3) <= sys.version_info < (3, 4),
+                     "Bug in jedi for Python 3.3")
+    def test_should_not_fail_for_relative_import(self):
+        # Bug in Rope: rope#81 and rope#82
+        source, offset = source_and_offset(
+            "from .. import foo_|_"
+        )
+        filename = self.project_file("test.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_on_keyword(self):
+        source, offset = source_and_offset(
+            "_|_try:\n"
+            "    pass\n"
+            "except:\n"
+            "    pass\n")
+        filename = self.project_file("test.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_with_bad_encoding(self):
+        # Bug in Rope: rope#83
+        source, offset = source_and_offset(
+            u'# coding: utf-8X_|_\n'
+        )
+        filename = self.project_file("test.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_with_form_feed_characters(self):
+        # Bug in Jedi: jedi#424
+        source, offset = source_and_offset(
+            "\f\n"
+            "class Test(object):_|_\n"
+            "    pass"
+        )
+        filename = self.project_file("test.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_for_dictionaries_in_weird_places(self):
+        # Bug in Jedi: jedi#417
+        source, offset = source_and_offset(
+            "import json\n"
+            "\n"
+            "def foo():\n"
+            "    json.loads(_|_\n"
+            "\n"
+            "    json.load.return_value = {'foo': [],\n"
+            "                              'bar': True}\n"
+            "\n"
+            "    c = Foo()\n"
+        )
+        filename = self.project_file("test.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_break_with_binary_characters_in_docstring(self):
+        # Bug in Jedi: jedi#427
+        template = '''\
+class Foo(object):
+    def __init__(self):
+        """
+        COMMUNITY instance that this conversion belongs to.
+        DISPERSY_VERSION is the dispersy conversion identifier (on the wire version; must be one byte).
+        COMMUNIY_VERSION is the community conversion identifier (on the wire version; must be one byte).
+
+        COMMUNIY_VERSION may not be '\\x00' or '\\xff'. '\\x00' is used by the DefaultConversion until
+        a proper conversion instance can be made for the Community.  '\\xff' is reserved for when
+        more than one byte is needed as a version indicator.
+        """
+        pass
+
+
+x = Foo()
+x._|_
+'''
+        source, offset = source_and_offset(template)
+        filename = self.project_file("test.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_for_def_without_name(self):
+        # Bug jedi#429
+        source, offset = source_and_offset(
+            "def_|_():\n"
+            "    if True:\n"
+            "        return True\n"
+            "    else:\n"
+            "        return False\n"
+        )
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_on_lambda(self):
+        # Bug #272 / jedi#431, jedi#572
+        source, offset = source_and_offset(
+            "map(lambda_|_"
+        )
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_on_literals(self):
+        # Bug #314, #344 / jedi#466
+        source = u'lit = u"""\\\n# -*- coding: utf-8 -*-\n"""\n'
+        offset = 0
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_with_args_as_args(self):
+        # Bug #347 in rope_py3k
+        source, offset = source_and_offset(
+            "def my_function(*args):\n"
+            "    ret_|_"
+        )
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_for_unicode_chars_in_string(self):
+        # Bug #358 / jedi#482
+        source = '''\
+# coding: utf-8
+
+logging.info(u"Saving «{}»...".format(title))
+requests.get(u"https://web.archive.org/save/{}".format(url))
+'''
+        offset = 57
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_for_bad_escape_sequence(self):
+        # Bug #360 / jedi#485
+        source = r"v = '\x'"
+        offset = 8
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_for_coding_declarations_in_strings(self):
+        # Bug #314 / jedi#465 / python#22221
+        source = u'lit = """\\\n# -*- coding: utf-8 -*-\n"""'
+        offset = 8
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_if_root_vanishes(self):
+        # Bug #353
+        source, offset = source_and_offset(
+            "import foo\n"
+            "foo._|_"
+        )
+        filename = self.project_file("project.py", source)
+        shutil.rmtree(self.project_root)
+
+        self.rpc(filename, source, offset)
+
+    # For some reason, this breaks a lot of other tests. Couldn't
+    # figure out why.
+    #
+    # def test_should_not_fail_for_sys_path(self):
+    #     # Bug #365 / jedi#486
+    #     source, offset = source_and_offset(
+    #         "import sys\n"
+    #         "\n"
+    #         "sys.path.index(_|_\n"
+    #     )
+    #     filename = self.project_file("project.py", source)
+    #
+    #     self.rpc(filename, source, offset)
+
+    def test_should_not_fail_for_key_error(self):
+        # Bug #561, #564, #570, #588, #593, #599 / jedi#572, jedi#579,
+        # jedi#590
+        source, offset = source_and_offset(
+            "map(lambda_|_"
+        )
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_for_badly_defined_global_variable(self):
+        # Bug #519 / jedi#610
+        source, offset = source_and_offset(
+            """\
+def funct1():
+    global global_dict_var
+    global_dict_var = dict()
+
+def funct2():
+    global global_dict_var
+    q = global_dict_var.copy_|_()
+    print(q)""")
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+    def test_should_not_fail_with_mergednamesdict(self):
+        # Bug #563 / jedi#589
+        source, offset = source_and_offset(
+            u'from email import message_|_'
+        )
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+
+class RPCGetCompletionsTests(GenericRPCTests):
+    METHOD = "rpc_get_completions"
+
+    def test_should_complete_builtin(self):
+        source, offset = source_and_offset("o_|_")
+
+        expected = self.BUILTINS
+        actual = [cand['name'] for cand in
+                  self.backend.rpc_get_completions("test.py",
+                                                   source, offset)]
+
+        for candidate in expected:
+            self.assertIn(candidate, actual)
+
+    if sys.version_info >= (3, 5):
+        JSON_COMPLETIONS = ["SONDecoder", "SONEncoder", "SONDecodeError"]
+    else:
+        JSON_COMPLETIONS = ["SONDecoder", "SONEncoder"]
+
+    def test_should_complete_imports(self):
+        source, offset = source_and_offset("import json\n"
+                                           "json.J_|_")
+        filename = self.project_file("test.py", source)
+        completions = self.backend.rpc_get_completions(filename,
+                                                       source,
+                                                       offset)
+        self.assertEqual(
+            sorted([cand['suffix'] for cand in completions]),
+            sorted(self.JSON_COMPLETIONS))
+
+    def test_should_complete_top_level_modules_for_import(self):
+        source, offset = source_and_offset("import multi_|_")
+        filename = self.project_file("test.py", source)
+        completions = self.backend.rpc_get_completions(filename,
+                                                       source,
+                                                       offset)
+        if compat.PYTHON3:
+            expected = ["processing"]
+        else:
+            expected = ["file", "processing"]
+        self.assertEqual(sorted([cand['suffix'] for cand in completions]),
+                         sorted(expected))
+
+    def test_should_complete_packages_for_import(self):
+        source, offset = source_and_offset("import email.mi_|_")
+        filename = self.project_file("test.py", source)
+        completions = self.backend.rpc_get_completions(filename,
+                                                       source,
+                                                       offset)
+        self.assertEqual([cand['suffix'] for cand in completions],
+                         ["me"])
+
+    def test_should_not_complete_for_import(self):
+        source, offset = source_and_offset("import foo.Conf_|_")
+        filename = self.project_file("test.py", source)
+        completions = self.backend.rpc_get_completions(filename,
+                                                       source,
+                                                       offset)
+        self.assertEqual([cand['suffix'] for cand in completions],
+                         [])
+
+    @unittest.skipIf((3, 3) <= sys.version_info < (3, 4),
+                     "Bug in jedi for Python 3.3")
+    def test_should_not_fail_for_short_module(self):
+        source, offset = source_and_offset("from .. import foo_|_")
+        filename = self.project_file("test.py", source)
+        completions = self.backend.rpc_get_completions(filename,
+                                                       source,
+                                                       offset)
+        self.assertIsNotNone(completions)
+
+    def test_should_complete_sys(self):
+        source, offset = source_and_offset("import sys\nsys._|_")
+        filename = self.project_file("test.py", source)
+        completions = self.backend.rpc_get_completions(filename,
+                                                       source,
+                                                       offset)
+        self.assertIn('path', [cand['suffix'] for cand in completions])
+
+    def test_should_find_with_trailing_text(self):
+        source, offset = source_and_offset(
+            "import threading\nthreading.T_|_mumble mumble")
+
+        expected = ["Thread", "ThreadError", "Timer"]
+        actual = [cand['name'] for cand in
+                  self.backend.rpc_get_completions("test.py", source, offset)]
+
+        for candidate in expected:
+            self.assertIn(candidate, actual)
+
+    def test_should_find_completion_different_package(self):
+        # See issue #74
+        self.project_file("project/__init__.py", "")
+        source1 = ("class Add:\n"
+                   "    def add(self, a, b):\n"
+                   "        return a + b\n")
+        self.project_file("project/add.py", source1)
+        source2, offset = source_and_offset(
+            "from project.add import Add\n"
+            "class Calculator:\n"
+            "    def add(self, a, b):\n"
+            "        c = Add()\n"
+            "        c.ad_|_\n")
+        file2 = self.project_file("project/calculator.py", source2)
+        proposals = self.backend.rpc_get_completions(file2,
+                                                     source2,
+                                                     offset)
+        self.assertEqual(["add"],
+                         [proposal["name"] for proposal in proposals])
+
+
+class RPCGetCompletionDocstringTests(object):
+    def test_should_return_docstring(self):
+        source, offset = source_and_offset("import json\n"
+                                           "json.JSONEnc_|_")
+        filename = self.project_file("test.py", source)
+        completions = self.backend.rpc_get_completions(filename,
+                                                       source,
+                                                       offset)
+        completions.sort(key=lambda p: p["name"])
+        prop = completions[0]
+        self.assertEqual(prop["name"], "JSONEncoder")
+
+        docs = self.backend.rpc_get_completion_docstring("JSONEncoder")
+
+        self.assertIn("Extensible JSON", docs)
+
+    def test_should_return_none_if_unknown(self):
+        docs = self.backend.rpc_get_completion_docstring("Foo")
+
+        self.assertIsNone(docs)
+
+
+class RPCGetCompletionLocationTests(object):
+    def test_should_return_location(self):
+        source, offset = source_and_offset("donaudampfschiff = 1\n"
+                                           "donau_|_")
+        filename = self.project_file("test.py", source)
+        completions = self.backend.rpc_get_completions(filename,
+                                                       source,
+                                                       offset)
+        prop = completions[0]
+        self.assertEqual(prop["name"], "donaudampfschiff")
+
+        loc = self.backend.rpc_get_completion_location("donaudampfschiff")
+
+        self.assertEqual((filename, 1), loc)
+
+    def test_should_return_none_if_unknown(self):
+        docs = self.backend.rpc_get_completion_location("Foo")
+
+        self.assertIsNone(docs)
+
+
+class RPCGetDefinitionTests(GenericRPCTests):
+    METHOD = "rpc_get_definition"
+
+    def test_should_return_definition_location_same_file(self):
+        source, offset = source_and_offset("import threading\n"
+                                           "def test_function(a, b):\n"
+                                           "    return a + b\n"
+                                           "\n"
+                                           "test_func_|_tion(\n")
+        filename = self.project_file("test.py", source)
+
+        location = self.backend.rpc_get_definition(filename,
+                                                   source,
+                                                   offset)
+
+        self.assertEqual(location[0], filename)
+        # On def or on the function name
+        self.assertIn(location[1], (17, 21))
+
+    def test_should_return_location_in_same_file_if_not_saved(self):
+        source, offset = source_and_offset(
+            "import threading\n"
+            "\n"
+            "\n"
+            "def other_function():\n"
+            "    test_f_|_unction(1, 2)\n"
+            "\n"
+            "\n"
+            "def test_function(a, b):\n"
+            "    return a + b\n")
+        filename = self.project_file("test.py", "")
+
+        location = self.backend.rpc_get_definition(filename,
+                                                   source,
+                                                   offset)
+
+        self.assertEqual(location[0], filename)
+        # def or function name
+        self.assertIn(location[1], (67, 71))
+
+    def test_should_return_location_in_different_file(self):
+        source1 = ("def test_function(a, b):\n"
+                   "    return a + b\n")
+        file1 = self.project_file("test1.py", source1)
+        source2, offset = source_and_offset("from test1 import test_function\n"
+                                            "test_funct_|_ion(1, 2)\n")
+        file2 = self.project_file("test2.py", source2)
+
+        definition = self.backend.rpc_get_definition(file2,
+                                                     source2,
+                                                     offset)
+
+        self.assertEqual(definition[0], file1)
+        # Either on the def or on the function name
+        self.assertIn(definition[1], (0, 4))
+
+    def test_should_return_none_if_location_not_found(self):
+        source, offset = source_and_offset("test_f_|_unction()\n")
+        filename = self.project_file("test.py", source)
+
+        definition = self.backend.rpc_get_definition(filename,
+                                                     source,
+                                                     offset)
+
+        self.assertIsNone(definition)
+
+    def test_should_return_none_if_outside_of_symbol(self):
+        source, offset = source_and_offset("test_function(_|_)\n")
+        filename = self.project_file("test.py", source)
+
+        definition = self.backend.rpc_get_definition(filename,
+                                                     source,
+                                                     offset)
+
+        self.assertIsNone(definition)
+
+    def test_should_return_definition_location_different_package(self):
+        # See issue #74
+        self.project_file("project/__init__.py", "")
+        source1 = ("class Add:\n"
+                   "    def add(self, a, b):\n"
+                   "        return a + b\n")
+        file1 = self.project_file("project/add.py", source1)
+        source2, offset = source_and_offset(
+            "from project.add import Add\n"
+            "class Calculator:\n"
+            "    def add(self, a, b):\n"
+            "        return Add_|_().add(a, b)\n")
+        file2 = self.project_file("project/calculator.py", source2)
+
+        location = self.backend.rpc_get_definition(file2,
+                                                   source2,
+                                                   offset)
+
+        self.assertEqual(location[0], file1)
+        # class or class name
+        self.assertIn(location[1], (0, 6))
+
+    def test_should_find_variable_definition(self):
+        source, offset = source_and_offset("SOME_VALUE = 1\n"
+                                           "\n"
+                                           "variable = _|_SOME_VALUE\n")
+        filename = self.project_file("test.py", source)
+        self.assertEqual(self.backend.rpc_get_definition(filename,
+                                                         source,
+                                                         offset),
+                         (filename, 0))
+
+
+class RPCGetAssignmentTests(GenericRPCTests):
+    METHOD = "rpc_get_assignment"
+
+    def test_should_return_assignment_location_same_file(self):
+        source, offset = source_and_offset("import threading\n"
+                                           "class TestClass(object):\n"
+                                           "    def __init__(self, a, b):\n"
+                                           "        self.a = a\n"
+                                           "        self.b = b\n"
+                                           "\n"
+                                           "testclass = TestClass(2, 4)"
+                                           "\n"
+                                           "testcl_|_ass(\n")
+        filename = self.project_file("test.py", source)
+
+        location = self.backend.rpc_get_assignment(filename,
+                                                   source,
+                                                   offset)
+
+        self.assertEqual(location[0], filename)
+        # On def or on the function name
+        self.assertEqual(location[1], 111)
+
+    def test_should_return_location_in_same_file_if_not_saved(self):
+        source, offset = source_and_offset("import threading\n"
+                                           "class TestClass(object):\n"
+                                           "    def __init__(self, a, b):\n"
+                                           "        self.a = a\n"
+                                           "        self.b = b\n"
+                                           "\n"
+                                           "testclass = TestClass(2, 4)"
+                                           "\n"
+                                           "testcl_|_ass(\n")
+        filename = self.project_file("test.py", "")
+
+        location = self.backend.rpc_get_assignment(filename,
+                                                   source,
+                                                   offset)
+
+        self.assertEqual(location[0], filename)
+        # def or function name
+        self.assertEqual(location[1], 111)
+
+    def test_should_return_location_in_different_file(self):
+        source1 = ("class TestClass(object):\n"
+                   "    def __init__(self, a, b):\n"
+                   "        self.a = a\n"
+                   "        self.b = b\n"
+                   "testclass = TestClass(3, 5)\n")
+        file1 = self.project_file("test1.py", source1)
+        source2, offset = source_and_offset("from test1 import testclass\n"
+                                            "testcl_|_ass.a\n")
+        file2 = self.project_file("test2.py", source2)
+        # First jump goes to import statement
+        assignment = self.backend.rpc_get_assignment(file2,
+                                                     source2,
+                                                     offset)
+        # Second jump goes to test1 file
+        self.assertEqual(assignment[0], file2)
+        assignment = self.backend.rpc_get_assignment(file2,
+                                                     source2,
+                                                     assignment[1])
+
+        self.assertEqual(assignment[0], file1)
+        self.assertEqual(assignment[1], 93)
+
+    def test_should_return_none_if_location_not_found(self):
+        source, offset = source_and_offset("test_f_|_unction()\n")
+        filename = self.project_file("test.py", source)
+
+        assignment = self.backend.rpc_get_assignment(filename,
+                                                     source,
+                                                     offset)
+
+        self.assertIsNone(assignment)
+
+    def test_should_return_none_if_outside_of_symbol(self):
+        source, offset = source_and_offset("testcl(_|_)ass\n")
+        filename = self.project_file("test.py", source)
+
+        assignment = self.backend.rpc_get_assignment(filename,
+                                                     source,
+                                                     offset)
+
+        self.assertIsNone(assignment)
+
+    def test_should_find_variable_assignment(self):
+        source, offset = source_and_offset("SOME_VALUE = 1\n"
+                                           "\n"
+                                           "variable = _|_SOME_VALUE\n")
+        filename = self.project_file("test.py", source)
+        self.assertEqual(self.backend.rpc_get_assignment(filename,
+                                                         source,
+                                                         offset),
+                         (filename, 0))
+
+
+class RPCGetCalltipTests(GenericRPCTests):
+    METHOD = "rpc_get_calltip"
+
+    @unittest.skipIf(sys.version_info >= (3, 0),
+                     "Bug in Jedi 0.9.0")
+    def test_should_get_calltip(self):
+        source, offset = source_and_offset(
+            "import threading\nthreading.Thread(_|_")
+        filename = self.project_file("test.py", source)
+        calltip = self.backend.rpc_get_calltip(filename,
+                                               source,
+                                               offset)
+
+        expected = self.THREAD_CALLTIP
+
+        self.assertEqual(calltip, expected)
+
+    @unittest.skipIf(sys.version_info >= (3, 0),
+                     "Bug in Jedi 0.9.0")
+    def test_should_get_calltip_even_after_parens(self):
+        source, offset = source_and_offset(
+            "import threading\nthreading.Thread(foo()_|_")
+        filename = self.project_file("test.py", source)
+
+        actual = self.backend.rpc_get_calltip(filename,
+                                              source,
+                                              offset)
+
+        self.assertEqual(self.THREAD_CALLTIP, actual)
+
+    @unittest.skipIf(sys.version_info >= (3, 0),
+                     "Bug in Jedi 0.9.0")
+    def test_should_get_calltip_at_closing_paren(self):
+        source, offset = source_and_offset(
+            "import threading\nthreading.Thread(_|_)")
+        filename = self.project_file("test.py", source)
+
+        actual = self.backend.rpc_get_calltip(filename,
+                                              source,
+                                              offset)
+
+        self.assertEqual(self.THREAD_CALLTIP, actual)
+
+    def test_should_not_missing_attribute_get_definition(self):
+        # Bug #627 / jedi#573
+        source, offset = source_and_offset(
+            "import threading\nthreading.Thread(_|_)")
+        filename = self.project_file("test.py", source)
+
+        self.backend.rpc_get_calltip(filename, source, offset)
+
+    def test_should_return_none_for_bad_identifier(self):
+        source, offset = source_and_offset(
+            "froblgoo(_|_")
+        filename = self.project_file("test.py", source)
+        calltip = self.backend.rpc_get_calltip(filename,
+                                               source,
+                                               offset)
+        self.assertIsNone(calltip)
+
+    def test_should_remove_self_argument(self):
+        source, offset = source_and_offset(
+            "d = dict()\n"
+            "d.keys(_|_")
+        filename = self.project_file("test.py", source)
+
+        actual = self.backend.rpc_get_calltip(filename,
+                                              source,
+                                              offset)
+
+        self.assertEqual(self.KEYS_CALLTIP, actual)
+
+    def test_should_remove_package_prefix(self):
+        source, offset = source_and_offset(
+            "import decimal\n"
+            "d = decimal.Decimal('1.5')\n"
+            "d.radix(_|_")
+        filename = self.project_file("test.py", source)
+
+        actual = self.backend.rpc_get_calltip(filename,
+                                              source,
+                                              offset)
+
+        self.assertEqual(self.RADIX_CALLTIP, actual)
+
+    def test_should_return_none_outside_of_all(self):
+        filename = self.project_file("test.py", "")
+        source, offset = source_and_offset("import thr_|_eading\n")
+        calltip = self.backend.rpc_get_calltip(filename,
+                                               source, offset)
+        self.assertIsNone(calltip)
+
+    def test_should_find_calltip_different_package(self):
+        # See issue #74
+        self.project_file("project/__init__.py", "")
+        source1 = ("class Add:\n"
+                   "    def add(self, a, b):\n"
+                   "        return a + b\n")
+        self.project_file("project/add.py", source1)
+        source2, offset = source_and_offset(
+            "from project.add import Add\n"
+            "class Calculator:\n"
+            "    def add(self, a, b):\n"
+            "        c = Add()\n"
+            "        c.add(_|_\n")
+        file2 = self.project_file("project/calculator.py", source2)
+
+        actual = self.backend.rpc_get_calltip(file2,
+                                              source2,
+                                              offset)
+
+        self.assertEqual(self.ADD_CALLTIP, actual)
+
+
+class RPCGetDocstringTests(GenericRPCTests):
+    METHOD = "rpc_get_docstring"
+
+    def check_docstring(self, docstring):
+
+        def first_line(s):
+            return s[:s.index("\n")]
+
+        self.assertEqual(first_line(docstring),
+                         self.JSON_LOADS_DOCSTRING)
+
+    def test_should_get_docstring(self):
+        source, offset = source_and_offset(
+            "import json\njson.loads_|_(")
+        filename = self.project_file("test.py", source)
+        docstring = self.backend.rpc_get_docstring(filename,
+                                                   source,
+                                                   offset)
+        self.check_docstring(docstring)
+
+    def test_should_return_none_for_bad_identifier(self):
+        source, offset = source_and_offset(
+            "froblgoo_|_(\n")
+        filename = self.project_file("test.py", source)
+        docstring = self.backend.rpc_get_docstring(filename,
+                                                   source,
+                                                   offset)
+        self.assertIsNone(docstring)
+
+
+class RPCGetNamesTests(GenericRPCTests):
+    METHOD = "rpc_get_names"
+
+    def test_shouldreturn_names_in_same_file(self):
+        filename = self.project_file("test.py", "")
+        source, offset = source_and_offset(
+            "def foo(x, y):\n"
+            "    return x + y\n"
+            "c = _|_foo(5, 2)\n")
+
+        names = self.backend.rpc_get_names(filename,
+                                           source,
+                                           offset)
+
+        self.assertEqual(names,
+                         [{'name': 'foo',
+                           'filename': filename,
+                           'offset': 4},
+                          {'name': 'x',
+                           'filename': filename,
+                           'offset': 8},
+                          {'name': 'y',
+                           'filename': filename,
+                           'offset': 11},
+                          {'name': 'x',
+                           'filename': filename,
+                           'offset': 26},
+                          {'name': 'y',
+                           'filename': filename,
+                           'offset': 30},
+                          {'name': 'c',
+                           'filename': filename,
+                           'offset': 32},
+                          {'name': 'foo',
+                           'filename': filename,
+                           'offset': 36}])
+
+    def test_should_not_fail_without_symbol(self):
+        filename = self.project_file("test.py", "")
+
+        names = self.backend.rpc_get_names(filename,
+                                           "",
+                                           0)
+
+        self.assertEqual(names, [])
+
+
+class RPCGetUsagesTests(GenericRPCTests):
+    METHOD = "rpc_get_usages"
+
+    def test_should_return_uses_in_same_file(self):
+        filename = self.project_file("test.py", "")
+        source, offset = source_and_offset(
+            "def foo(x):\n"
+            "    return _|_x + x\n")
+
+        usages = self.backend.rpc_get_usages(filename,
+                                             source,
+                                             offset)
+
+        self.assertEqual(usages,
+                         [{'name': 'x',
+                           'offset': 8,
+                           'filename': filename},
+                          {'name': 'x',
+                           'filename': filename,
+                           'offset': 23},
+                          {'name': u'x',
+                           'filename': filename,
+                           'offset': 27}])
+
+    def test_should_return_uses_in_other_file(self):
+        file1 = self.project_file("file1.py", "")
+        file2 = self.project_file("file2.py", "\n\n\n\n\nx = 5")
+        source, offset = source_and_offset(
+            "import file2\n"
+            "file2._|_x\n")
+
+        usages = self.backend.rpc_get_usages(file1,
+                                             source,
+                                             offset)
+
+        self.assertEqual(usages,
+                         [{'name': 'x',
+                           'filename': file1,
+                           'offset': 19},
+                          {'name': 'x',
+                           'filename': file2,
+                           'offset': 5}])
+
+    def test_should_not_fail_without_symbol(self):
+        filename = self.project_file("file.py", "")
+
+        usages = self.backend.rpc_get_usages(filename,
+                                             "",
+                                             0)
+
+        self.assertEqual(usages, [])
+
+
+def source_and_offset(source):
+    """Return a source and offset from a source description.
+
+    >>> source_and_offset("hello, _|_world")
+    ("hello, world", 7)
+    >>> source_and_offset("_|_hello, world")
+    ("hello, world", 0)
+    >>> source_and_offset("hello, world_|_")
+    ("hello, world", 12)
+    """
+    offset = source.index("_|_")
+    return source[:offset] + source[offset + 3:], offset

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_auto_pep8.py

@@ -0,0 +1,20 @@
+# coding: utf-8
+
+"""Tests for the elpy.autopep8 module"""
+
+import unittest
+
+from elpy import auto_pep8
+from elpy.tests.support import BackendTestCase
+
+
+class Autopep8TestCase(BackendTestCase):
+
+    def setUp(self):
+        if not auto_pep8.autopep8:
+            raise unittest.SkipTest
+
+    def test_fix_code(self):
+        code_block = 'x=       123\n'
+        new_block = auto_pep8.fix_code(code_block)
+        self.assertEqual(new_block, 'x = 123\n')

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_impmagic.py

@@ -0,0 +1,73 @@
+# coding: utf-8
+
+"""Tests for the elpy.impmagic module"""
+
+import re
+import sys
+import unittest
+
+from elpy import impmagic
+from elpy.tests.support import BackendTestCase
+
+TEST_SOURCE = '''# test file
+
+import time
+import logging
+
+os.getcwd()
+time.sleep(1)
+'''
+
+
+@unittest.skipIf(sys.version_info >= (3, 5), "importmagic fails in 3.5")
+class ImportMagicTestCase(BackendTestCase):
+    def setUp(self):
+        if not impmagic.importmagic:
+            raise unittest.SkipTest
+        self.importmagic = impmagic.ImportMagic()
+        super(ImportMagicTestCase, self).setUp()
+
+    def build_index(self):
+        self.project_file('mymod.py', 'class AnUncommonName:\n pass\n')
+        self.importmagic.build_index(self.project_root,
+                                     custom_path=[self.project_root],
+                                     blacklist_re=re.compile('^$'))
+        self.importmagic._thread.join()
+
+    def test_get_symbols(self):
+        self.build_index()
+        candidates = self.importmagic.get_import_symbols('AnUncommonName')
+        self.assertEqual(candidates, ['from mymod import AnUncommonName'])
+        candidates = self.importmagic.get_import_symbols('mymod')
+        self.assertEqual(candidates, ['import mymod'])
+
+    def test_add_import(self):
+        self.build_index()
+        start, end, newblock = self.importmagic.add_import(
+            TEST_SOURCE, 'from mymod import AnUncommonName')
+        self.assertEqual(start, 2)
+        self.assertEqual(end, 5)
+        self.assertEqual(newblock.strip(),
+                         'import logging\n'
+                         'import time\n'
+                         'from mymod import AnUncommonName')
+
+        start, end, newblock = self.importmagic.add_import(
+            TEST_SOURCE, 'import mymod')
+        self.assertEqual(start, 2)
+        self.assertEqual(end, 5)
+        self.assertEqual(newblock.strip(),
+                         'import logging\nimport mymod\nimport time')
+
+    def test_get_unresolved_symbols(self):
+        self.build_index()
+        symbols = self.importmagic.get_unresolved_symbols('x = a + b\ny = c.d')
+        self.assertEqual(sorted(symbols), ['a', 'b', 'c.d'])
+
+    def test_remove_unreferenced_imports(self):
+        self.build_index()
+        start, end, newblock = \
+            self.importmagic.remove_unreferenced_imports(TEST_SOURCE)
+        self.assertEqual(start, 2)
+        self.assertEqual(end, 5)
+        self.assertEqual(newblock.strip(), 'import time')

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_jedibackend.py

@@ -0,0 +1,317 @@
+"""Tests for the elpy.jedibackend module."""
+
+import sys
+import unittest
+
+import jedi
+import mock
+
+from elpy import jedibackend
+from elpy import rpc
+from elpy.tests import compat
+from elpy.tests.support import BackendTestCase
+from elpy.tests.support import RPCGetCompletionsTests
+from elpy.tests.support import RPCGetCompletionDocstringTests
+from elpy.tests.support import RPCGetCompletionLocationTests
+from elpy.tests.support import RPCGetDocstringTests
+from elpy.tests.support import RPCGetDefinitionTests
+from elpy.tests.support import RPCGetAssignmentTests
+from elpy.tests.support import RPCGetCalltipTests
+from elpy.tests.support import RPCGetUsagesTests
+from elpy.tests.support import RPCGetNamesTests
+
+
+class JediBackendTestCase(BackendTestCase):
+    def setUp(self):
+        super(JediBackendTestCase, self).setUp()
+        self.backend = jedibackend.JediBackend(self.project_root)
+
+
+class TestInit(JediBackendTestCase):
+    def test_should_have_jedi_as_name(self):
+        self.assertEqual(self.backend.name, "jedi")
+
+
+class TestRPCGetCompletions(RPCGetCompletionsTests,
+                            JediBackendTestCase):
+    BUILTINS = ['object', 'oct', 'open', 'ord', 'OSError', 'OverflowError']
+
+
+class TestRPCGetCompletionDocstring(RPCGetCompletionDocstringTests,
+                                    JediBackendTestCase):
+    pass
+
+
+class TestRPCGetCompletionLocation(RPCGetCompletionLocationTests,
+                                   JediBackendTestCase):
+    pass
+
+
+class TestRPCGetDocstring(RPCGetDocstringTests,
+                          JediBackendTestCase):
+    JSON_LOADS_DOCSTRING = (
+        'loads(s, encoding=None, cls=None, '
+        'object_hook=None, parse_float=None,'
+    )
+
+    def check_docstring(self, docstring):
+        lines = docstring.splitlines()
+        self.assertEqual(lines[0], 'Documentation for json.loads:')
+        self.assertEqual(lines[2], self.JSON_LOADS_DOCSTRING)
+
+    @mock.patch("elpy.jedibackend.run_with_debug")
+    def test_should_not_return_empty_docstring(self, run_with_debug):
+        location = mock.MagicMock()
+        location.full_name = "testthing"
+        location.docstring.return_value = ""
+        run_with_debug.return_value = [location]
+        filename = self.project_file("test.py", "print")
+        docstring = self.backend.rpc_get_docstring(filename, "print", 0)
+        self.assertIsNone(docstring)
+
+
+class TestRPCGetDefinition(RPCGetDefinitionTests,
+                           JediBackendTestCase):
+    @mock.patch("jedi.Script")
+    def test_should_not_fail_if_module_path_is_none(self, Script):
+        """Do not fail if loc.module_path is None.
+
+        This can happen under some circumstances I am unsure about.
+        See #537 for the issue that reported this.
+
+        """
+        locations = [
+            mock.Mock(module_path=None)
+        ]
+        script = Script.return_value
+        script.goto_definitions.return_value = locations
+        script.goto_assignments.return_value = locations
+
+        location = self.rpc("", "", 0)
+
+        self.assertIsNone(location)
+
+
+class TestRPCGetAssignment(RPCGetAssignmentTests,
+                           JediBackendTestCase):
+    @mock.patch("jedi.Script")
+    def test_should_not_fail_if_module_path_is_none(self, Script):
+        """Do not fail if loc.module_path is None.
+
+        """
+        locations = [
+            mock.Mock(module_path=None)
+        ]
+        script = Script.return_value
+        script.goto_assignments.return_value = locations
+        script.goto_assignments.return_value = locations
+
+        location = self.rpc("", "", 0)
+
+        self.assertIsNone(location)
+
+
+class TestRPCGetCalltip(RPCGetCalltipTests,
+                        JediBackendTestCase):
+    KEYS_CALLTIP = {'index': 0,
+                    'params': ['param '],
+                    'name': u'keys'}
+    RADIX_CALLTIP = {'index': None,
+                     'params': [],
+                     'name': u'radix'}
+    ADD_CALLTIP = {'index': 0,
+                   'params': [u'param a', u'param b'],
+                   'name': u'add'}
+    if compat.PYTHON3:
+        THREAD_CALLTIP = {"name": "Thread",
+                          "params": ["group=None",
+                                     "target=None",
+                                     "name=None",
+                                     "args=()",
+                                     "kwargs=None",
+                                     "daemon=None"],
+                          "index": 0}
+    else:
+        THREAD_CALLTIP = {"name": "Thread",
+                          "params": ["param group=None",
+                                     "param target=None",
+                                     "param name=None",
+                                     "param args=()",
+                                     "param kwargs=None",
+                                     "param verbose=None"],
+                          "index": 0}
+
+    def test_should_not_fail_with_get_subscope_by_name(self):
+        # Bug #677 / jedi#628
+        source = (
+            u"my_lambda = lambda x: x+1\n"
+            u"my_lambda(1)"
+        )
+        filename = self.project_file("project.py", source)
+        offset = 37
+
+        sigs = self.backend.rpc_get_calltip(filename, source, offset)
+        sigs["index"]
+
+
+class TestRPCGetUsages(RPCGetUsagesTests,
+                       JediBackendTestCase):
+    def test_should_not_fail_for_missing_module(self):
+        # This causes use.module_path to be None
+        source = "import sys\n\nsys.path.\n"  # insert()"
+        offset = 21
+        filename = self.project_file("project.py", source)
+
+        self.rpc(filename, source, offset)
+
+
+class TestRPCGetNames(RPCGetNamesTests,
+                      JediBackendTestCase):
+    pass
+
+
+class TestPosToLinecol(unittest.TestCase):
+    def test_should_handle_beginning_of_string(self):
+        self.assertEqual(jedibackend.pos_to_linecol("foo", 0),
+                         (1, 0))
+
+    def test_should_handle_end_of_line(self):
+        self.assertEqual(jedibackend.pos_to_linecol("foo\nbar\nbaz\nqux", 9),
+                         (3, 1))
+
+    def test_should_handle_end_of_string(self):
+        self.assertEqual(jedibackend.pos_to_linecol("foo\nbar\nbaz\nqux", 14),
+                         (4, 2))
+
+
+class TestLinecolToPos(unittest.TestCase):
+    def test_should_handle_beginning_of_string(self):
+        self.assertEqual(jedibackend.linecol_to_pos("foo", 1, 0),
+                         0)
+
+    def test_should_handle_end_of_string(self):
+        self.assertEqual(jedibackend.linecol_to_pos("foo\nbar\nbaz\nqux",
+                                                    3, 1),
+                         9)
+
+    def test_should_return_offset(self):
+        self.assertEqual(jedibackend.linecol_to_pos("foo\nbar\nbaz\nqux",
+                                                    4, 2),
+                         14)
+
+    def test_should_fail_for_line_past_text(self):
+        self.assertRaises(ValueError,
+                          jedibackend.linecol_to_pos, "foo\n", 3, 1)
+
+    def test_should_fail_for_column_past_text(self):
+        self.assertRaises(ValueError,
+                          jedibackend.linecol_to_pos, "foo\n", 1, 10)
+
+
+class TestRunWithDebug(unittest.TestCase):
+    @mock.patch('jedi.Script')
+    def test_should_call_method(self, Script):
+        Script.return_value.test_method.return_value = "test-result"
+
+        result = jedibackend.run_with_debug(jedi, 'test_method', 1, 2, arg=3)
+
+        Script.assert_called_with(1, 2, arg=3)
+        self.assertEqual(result, 'test-result')
+
+    @mock.patch('jedi.Script')
+    def test_should_re_raise(self, Script):
+        Script.side_effect = RuntimeError
+
+        with self.assertRaises(RuntimeError):
+            jedibackend.run_with_debug(jedi, 'test_method', 1, 2, arg=3,
+                                       re_raise=(RuntimeError,))
+
+    @mock.patch('jedi.Script')
+    @mock.patch('jedi.set_debug_function')
+    def test_should_keep_debug_info(self, set_debug_function, Script):
+        Script.side_effect = RuntimeError
+
+        try:
+            jedibackend.run_with_debug(jedi, 'test_method', 1, 2, arg=3)
+        except rpc.Fault as e:
+            self.assertGreaterEqual(e.code, 400)
+            self.assertIsNotNone(e.data)
+            self.assertIn("traceback", e.data)
+            jedi_debug_info = e.data["jedi_debug_info"]
+            self.assertIsNotNone(jedi_debug_info)
+            self.assertEqual(jedi_debug_info["script_args"],
+                             "1, 2, arg=3")
+            self.assertEqual(jedi_debug_info["source"], None)
+            self.assertEqual(jedi_debug_info["method"], "test_method")
+            self.assertEqual(jedi_debug_info["debug_info"], [])
+        else:
+            self.fail("Fault not thrown")
+
+    @mock.patch('jedi.Script')
+    @mock.patch('jedi.set_debug_function')
+    def test_should_keep_error_text(self, set_debug_function, Script):
+        Script.side_effect = RuntimeError
+
+        try:
+            jedibackend.run_with_debug(jedi, 'test_method', 1, 2, arg=3)
+        except rpc.Fault as e:
+            self.assertEqual(str(e), str(RuntimeError()))
+            self.assertEqual(e.message, str(RuntimeError()))
+        else:
+            self.fail("Fault not thrown")
+
+    @mock.patch('jedi.Script')
+    @mock.patch('jedi.set_debug_function')
+    def test_should_handle_source_special(self, set_debug_function, Script):
+        Script.side_effect = RuntimeError
+
+        try:
+            jedibackend.run_with_debug(jedi, 'test_method', source="foo")
+        except rpc.Fault as e:
+            self.assertEqual(e.data["jedi_debug_info"]["script_args"],
+                             "source=source")
+            self.assertEqual(e.data["jedi_debug_info"]["source"], "foo")
+        else:
+            self.fail("Fault not thrown")
+
+    @mock.patch('jedi.Script')
+    @mock.patch('jedi.set_debug_function')
+    def test_should_set_debug_info(self, set_debug_function, Script):
+        the_debug_function = [None]
+
+        def my_set_debug_function(debug_function, **kwargs):
+            the_debug_function[0] = debug_function
+
+        def my_script(*args, **kwargs):
+            the_debug_function[0](jedi.debug.NOTICE, "Notice")
+            the_debug_function[0](jedi.debug.WARNING, "Warning")
+            the_debug_function[0]("other", "Other")
+            raise RuntimeError
+
+        set_debug_function.side_effect = my_set_debug_function
+        Script.return_value.test_method = my_script
+
+        try:
+            jedibackend.run_with_debug(jedi, 'test_method', source="foo")
+        except rpc.Fault as e:
+            self.assertEqual(e.data["jedi_debug_info"]["debug_info"],
+                             ["[N] Notice",
+                              "[W] Warning",
+                              "[?] Other"])
+        else:
+            self.fail("Fault not thrown")
+
+    @mock.patch('jedi.set_debug_function')
+    @mock.patch('jedi.Script')
+    def test_should_not_fail_with_bad_data(self, Script, set_debug_function):
+        import jedi.debug
+
+        def set_debug(function, speed=True):
+            if function is not None:
+                function(jedi.debug.NOTICE, u"\xab")
+
+        set_debug_function.side_effect = set_debug
+        Script.return_value.test_method.side_effect = Exception
+
+        with self.assertRaises(rpc.Fault):
+            jedibackend.run_with_debug(jedi, 'test_method', 1, 2, arg=3)

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_pydocutils.py

@@ -0,0 +1,88 @@
+import os
+import unittest
+import shutil
+import sys
+import tempfile
+
+import mock
+
+import elpy.pydocutils
+
+
+class TestGetPydocCompletions(unittest.TestCase):
+    def test_should_return_top_level_modules(self):
+        modules = elpy.pydocutils.get_pydoc_completions("")
+        self.assertIn('sys', modules)
+        self.assertIn('json', modules)
+
+    def test_should_return_submodules(self):
+        modules = elpy.pydocutils.get_pydoc_completions("elpy")
+        self.assertIn("elpy.rpc", modules)
+        self.assertIn("elpy.server", modules)
+        modules = elpy.pydocutils.get_pydoc_completions("os")
+        self.assertIn("os.path", modules)
+
+    def test_should_find_objects_in_module(self):
+        self.assertIn("elpy.tests.test_pydocutils.TestGetPydocCompletions",
+                      elpy.pydocutils.get_pydoc_completions
+                      ("elpy.tests.test_pydocutils"))
+
+    def test_should_find_attributes_of_objects(self):
+        attribs = elpy.pydocutils.get_pydoc_completions(
+            "elpy.tests.test_pydocutils.TestGetPydocCompletions")
+        self.assertIn("elpy.tests.test_pydocutils.TestGetPydocCompletions."
+                      "test_should_find_attributes_of_objects",
+                      attribs)
+
+    def test_should_return_none_for_inexisting_module(self):
+        self.assertEqual([],
+                         elpy.pydocutils.get_pydoc_completions
+                         ("does_not_exist"))
+
+    def test_should_work_for_unicode_strings(self):
+        self.assertIsNotNone(elpy.pydocutils.get_pydoc_completions
+                             (u"sys"))
+
+    def test_should_find_partial_completions(self):
+        self.assertIn("multiprocessing",
+                      elpy.pydocutils.get_pydoc_completions
+                      ("multiprocess"))
+        self.assertIn("multiprocessing.util",
+                      elpy.pydocutils.get_pydoc_completions
+                      ("multiprocessing.ut"))
+
+    def test_should_ignore_trailing_dot(self):
+        self.assertIn("elpy.pydocutils",
+                      elpy.pydocutils.get_pydoc_completions
+                      ("elpy."))
+
+
+class TestGetModules(unittest.TestCase):
+    def test_should_return_top_level_modules(self):
+        modules = elpy.pydocutils.get_modules()
+        self.assertIn('sys', modules)
+        self.assertIn('json', modules)
+
+    def test_should_return_submodules(self):
+        modules = elpy.pydocutils.get_modules("elpy")
+        self.assertIn("rpc", modules)
+        self.assertIn("server", modules)
+
+    @mock.patch.object(elpy.pydocutils, 'safeimport')
+    def test_should_catch_import_errors(self, safeimport):
+        def raise_function(message):
+            raise elpy.pydocutils.ErrorDuringImport(message,
+                                                    (None, None, None))
+        safeimport.side_effect = raise_function
+        self.assertEqual([], elpy.pydocutils.get_modules("foo.bar"))
+
+    def test_should_not_fail_for_permission_denied(self):
+        tmpdir = tempfile.mkdtemp(prefix="test-elpy-get-modules-")
+        sys.path.append(tmpdir)
+        os.chmod(tmpdir, 0o000)
+        try:
+            elpy.pydocutils.get_modules()
+        finally:
+            os.chmod(tmpdir, 0o755)
+            shutil.rmtree(tmpdir)
+            sys.path.remove(tmpdir)

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_refactor.py

@@ -0,0 +1,545 @@
+import unittest
+import tempfile
+import shutil
+import os
+import mock
+import sys
+
+from elpy import refactor
+from textwrap import dedent
+
+
+class RefactorTestCase(unittest.TestCase):
+    def setUp(self):
+        self.project_root = tempfile.mkdtemp(prefix="test-refactor-root")
+        self.addCleanup(shutil.rmtree, self.project_root,
+                        ignore_errors=True)
+
+    def create_file(self, name, contents=""):
+        filename = os.path.join(self.project_root, name)
+        contents = dedent(contents)
+        offset = contents.find("_|_")
+        if offset > -1:
+            contents = contents[:offset] + contents[offset + 3:]
+        with open(filename, "w") as f:
+            f.write(contents)
+        return filename, offset
+
+    def assertSourceEqual(self, first, second, msg=None):
+        """Fail if the two objects are unequal, ignoring indentation."""
+        self.assertEqual(dedent(first), dedent(second), msg=msg)
+
+
+class TestGetRefactorOptions(RefactorTestCase):
+    def test_should_only_return_importsmodule_if_not_on_symbol(self):
+        filename, offset = self.create_file("foo.py",
+                                            """\
+                                            import foo
+                                            _|_""")
+        ref = refactor.Refactor(self.project_root, filename)
+        options = ref.get_refactor_options(offset)
+        self.assertTrue(all(opt['category'] in ('Imports',
+                                                'Module')
+                            for opt in options))
+        filename, offset = self.create_file("foo.py",
+                                            """\
+                                            _|_
+                                            import foo""")
+        ref = refactor.Refactor(self.project_root, filename)
+        options = ref.get_refactor_options(offset)
+        self.assertTrue(all(opt['category'] in ('Imports',
+                                                'Module')
+                            for opt in options))
+
+    def test_should_return_all_if_on_symbol(self):
+        filename, offset = self.create_file("foo.py",
+                                            "import _|_foo")
+        ref = refactor.Refactor(self.project_root, filename)
+        options = ref.get_refactor_options(offset)
+        self.assertTrue(all(opt['category'] in ('Imports',
+                                                'Method',
+                                                'Module',
+                                                'Symbol')
+                            for opt in options))
+
+    def test_should_return_only_region_if_endoffset(self):
+        filename, offset = self.create_file("foo.py",
+                                            "import foo")
+        ref = refactor.Refactor(self.project_root, filename)
+        options = ref.get_refactor_options(offset, 5)
+        self.assertTrue(all(opt['category'] == 'Region'
+                            for opt in options))
+
+    @unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+    def test_should_treat_from_import_special(self):
+        filename, offset = self.create_file("foo.py",
+                                            """\
+                                            import foo
+                                            _|_""")
+        ref = refactor.Refactor(self.project_root, filename)
+        options = ref.get_refactor_options(offset)
+        self.assertFalse(any(opt['name'] == "refactor_froms_to_imports"
+                             for opt in options))
+        filename, offset = self.create_file("foo.py",
+                                            "imp_|_ort foo")
+        ref = refactor.Refactor(self.project_root, filename)
+        options = ref.get_refactor_options(offset)
+        self.assertTrue(any(opt['name'] == "refactor_froms_to_imports"
+                            for opt in options))
+
+
+class TestGetChanges(RefactorTestCase):
+    def test_should_fail_if_method_is_not_refactoring(self):
+        filename, offset = self.create_file("foo.py")
+        ref = refactor.Refactor(self.project_root, filename)
+        self.assertRaises(ValueError, ref.get_changes, "bad_name")
+
+    def test_should_return_method_results(self):
+        filename, offset = self.create_file("foo.py")
+        ref = refactor.Refactor(self.project_root, filename)
+        with mock.patch.object(ref, 'refactor_extract_method') as test:
+            test.return_value = "Meep!"
+            self.assertEqual(ref.get_changes("refactor_extract_method",
+                                             1, 2),
+                             "Meep!")
+            test.assert_called_with(1, 2)
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestIsOnSymbol(RefactorTestCase):
+    def test_should_find_symbol(self):
+        filename, offset = self.create_file("test.py", "__B_|_AR = 100")
+        r = refactor.Refactor(self.project_root, filename)
+        self.assertTrue(r._is_on_symbol(offset))
+
+    # Issue #111
+    def test_should_find_symbol_with_underscores(self):
+        filename, offset = self.create_file("test.py", "_|___BAR = 100")
+        r = refactor.Refactor(self.project_root, filename)
+        self.assertTrue(r._is_on_symbol(offset))
+
+    def test_should_not_find_weird_places(self):
+        filename, offset = self.create_file("test.py", "hello = _|_ 1 + 1")
+        r = refactor.Refactor(self.project_root, filename)
+        self.assertFalse(r._is_on_symbol(offset))
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestFromsToImports(RefactorTestCase):
+    def test_should_refactor(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            """\
+            _|_from datetime import datetime
+
+            d = datetime(2013, 4, 7)
+            """)
+        ref = refactor.Refactor(self.project_root, filename)
+        (change,) = ref.get_changes("refactor_froms_to_imports", offset)
+        self.assertEqual(change['action'], 'change')
+        self.assertEqual(change['file'], filename)
+        self.assertSourceEqual(change['contents'],
+                               """\
+                               import datetime
+
+                               d = datetime.datetime(2013, 4, 7)
+                               """)
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestOrganizeImports(RefactorTestCase):
+    def test_should_refactor(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            """\
+            import unittest, base64
+            import datetime, json
+
+            obj = json.dumps(23)
+            unittest.TestCase()
+            """)
+        ref = refactor.Refactor(self.project_root, filename)
+        (change,) = ref.get_changes("refactor_organize_imports")
+        self.assertEqual(change['action'], 'change')
+        self.assertEqual(change['file'], filename)
+        self.assertSourceEqual(change['contents'],
+                               """\
+                               import json
+                               import unittest
+
+
+                               obj = json.dumps(23)
+                               unittest.TestCase()
+                               """)
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestModuleToPackage(RefactorTestCase):
+    def test_should_refactor(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            "_|_import os\n")
+        ref = refactor.Refactor(self.project_root, filename)
+        changes = ref.refactor_module_to_package()
+        a, b, c = changes
+        # Not sure why the a change is there. It's a CHANGE that
+        # changes nothing...
+        self.assertEqual(a['diff'], '')
+
+        self.assertEqual(b['action'], 'create')
+        self.assertEqual(b['type'], 'directory')
+        self.assertEqual(b['path'], os.path.join(self.project_root, "foo"))
+
+        self.assertEqual(c['action'], 'move')
+        self.assertEqual(c['type'], 'file')
+        self.assertEqual(c['source'], os.path.join(self.project_root,
+                                                   "foo.py"))
+        self.assertEqual(c['destination'], os.path.join(self.project_root,
+                                                        "foo/__init__.py"))
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestRenameAtPoint(RefactorTestCase):
+    def test_should_refactor(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            """\
+            class Foo(object):
+                def _|_foo(self):
+                    return 5
+
+                def bar(self):
+                    return self.foo()
+            """)
+        file2, offset2 = self.create_file(
+            "bar.py",
+            """\
+            import foo
+
+
+            x = foo.Foo()
+            x.foo()""")
+        ref = refactor.Refactor(self.project_root, filename)
+        first, second = ref.refactor_rename_at_point(offset, "frob",
+                                                     in_hierarchy=False,
+                                                     docs=False)
+        if first['file'] == filename:
+            a, b = first, second
+        else:
+            a, b = second, first
+        self.assertEqual(a['action'], 'change')
+        self.assertEqual(a['file'], filename)
+        self.assertSourceEqual(a['contents'],
+                               """\
+                               class Foo(object):
+                                   def frob(self):
+                                       return 5
+
+                                   def bar(self):
+                                       return self.frob()
+                               """)
+        self.assertEqual(b['action'], 'change')
+        self.assertEqual(b['file'], file2)
+        self.assertSourceEqual(b['contents'],
+                               """\
+                               import foo
+
+
+                               x = foo.Foo()
+                               x.frob()""")
+
+    def test_should_refactor_in_hierarchy(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            """\
+            class Foo(object):
+                def _|_foo(self):
+                    return 5
+
+                def bar(self):
+                    return self.foo()
+
+            class Bar(Foo):
+                def foo(self):
+                    return 42
+
+            class Baz(object):
+                def foo(self):
+                    return 42
+            """)
+        file2, offset2 = self.create_file(
+            "bar.py",
+            """\
+            import foo
+
+
+            x, y, z = foo.Foo(), foo.Bar(), foo.Baz()
+            x.foo()
+            y.foo()
+            z.foo()""")
+        ref = refactor.Refactor(self.project_root, filename)
+        first, second = ref.refactor_rename_at_point(offset, "frob",
+                                                     in_hierarchy=True,
+                                                     docs=False)
+        if first['file'] == filename:
+            a, b = first, second
+        else:
+            a, b = second, first
+        self.assertEqual(a['action'], 'change')
+        self.assertEqual(a['file'], filename)
+        self.assertSourceEqual(a['contents'],
+                               """\
+                               class Foo(object):
+                                   def frob(self):
+                                       return 5
+
+                                   def bar(self):
+                                       return self.frob()
+
+                               class Bar(Foo):
+                                   def frob(self):
+                                       return 42
+
+                               class Baz(object):
+                                   def foo(self):
+                                       return 42
+                               """)
+        self.assertEqual(b['action'], 'change')
+        self.assertEqual(b['file'], file2)
+        self.assertSourceEqual(b['contents'],
+                               """\
+                               import foo
+
+
+                               x, y, z = foo.Foo(), foo.Bar(), foo.Baz()
+                               x.frob()
+                               y.frob()
+                               z.foo()""")
+
+    def test_should_refactor_in_docstrings(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            """\
+            class Foo(object):
+                "Frobnicate the foo"
+                def _|_foo(self):
+                    return 5
+
+            print("I'm an unrelated foo")
+            """)
+        ref = refactor.Refactor(self.project_root, filename)
+        (change,) = ref.refactor_rename_at_point(offset, "frob",
+                                                 in_hierarchy=False,
+                                                 docs=True)
+        self.assertEqual(change['action'], 'change')
+        self.assertEqual(change['file'], filename)
+        self.assertSourceEqual(change['contents'],
+                               """\
+                               class Foo(object):
+                                   "Frobnicate the frob"
+                                   def frob(self):
+                                       return 5
+
+                               print("I'm an unrelated foo")
+                               """)
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestRenameCurrentModule(RefactorTestCase):
+    def test_should_refactor(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            "_|_import os\n")
+        file2, offset = self.create_file(
+            "bar.py",
+            """\
+            _|_import foo
+            foo.os
+            """)
+        dest = os.path.join(self.project_root, "frob.py")
+        ref = refactor.Refactor(self.project_root, filename)
+        a, b = ref.refactor_rename_current_module("frob")
+
+        self.assertEqual(a['action'], 'change')
+        self.assertEqual(a['file'], file2)
+        self.assertEqual(a['contents'],
+                         "import frob\n"
+                         "frob.os\n")
+
+        self.assertEqual(b['action'], 'move')
+        self.assertEqual(b['type'], 'file')
+        self.assertEqual(b['source'], filename)
+        self.assertEqual(b['destination'], dest)
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestMoveModule(RefactorTestCase):
+    def test_should_refactor(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            "_|_import os\n")
+        file2, offset = self.create_file(
+            "bar.py",
+            """\
+            _|_import foo
+            foo.os
+            """)
+        dest = os.path.join(self.project_root, "frob")
+        os.mkdir(dest)
+        with open(os.path.join(dest, "__init__.py"), "w") as f:
+            f.write("")
+        ref = refactor.Refactor(self.project_root, filename)
+        a, b = ref.refactor_move_module(dest)
+
+        self.assertEqual(a['action'], 'change')
+        self.assertEqual(a['file'], file2)
+        self.assertSourceEqual(a['contents'],
+                               """\
+                               import frob.foo
+                               frob.foo.os
+                               """)
+
+        self.assertEqual(b['action'], 'move')
+        self.assertEqual(b['type'], 'file')
+        self.assertEqual(b['source'], filename)
+        self.assertEqual(b['destination'],
+                         os.path.join(dest, "foo.py"))
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestCreateInline(RefactorTestCase):
+    def setUp(self):
+        super(TestCreateInline, self).setUp()
+        self.filename, self.offset = self.create_file(
+            "foo.py",
+            """\
+            def add(a, b):
+                return a + b
+
+            x = _|_add(2, 3)
+            y = add(17, 4)
+            """)
+
+    def test_should_refactor_single_occurrenc(self):
+        ref = refactor.Refactor(self.project_root, self.filename)
+        (change,) = ref.refactor_create_inline(self.offset, True)
+
+        self.assertEqual(change['action'], 'change')
+        self.assertEqual(change['file'], self.filename)
+        self.assertSourceEqual(change['contents'],
+                               """\
+                               def add(a, b):
+                                   return a + b
+
+                               x = 2 + 3
+                               y = add(17, 4)
+                               """)
+
+    def test_should_refactor_all_occurrencs(self):
+        ref = refactor.Refactor(self.project_root, self.filename)
+        (change,) = ref.refactor_create_inline(self.offset, False)
+
+        self.assertEqual(change['action'], 'change')
+        self.assertEqual(change['file'], self.filename)
+        self.assertSourceEqual(change['contents'],
+                               """\
+                               x = 2 + 3
+                               y = 17 + 4
+                               """)
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestExtractMethod(RefactorTestCase):
+    def setUp(self):
+        super(TestExtractMethod, self).setUp()
+        self.filename, self.offset = self.create_file(
+            "foo.py",
+            """\
+            class Foo(object):
+                def spaghetti(self, a, b):
+                    _|_x = a + 5
+                    y = b + 23
+                    return y
+            """)
+
+    @unittest.skipIf(sys.version_info >= (3, 5), "Python 3.5 not supported")
+    def test_should_refactor_local(self):
+        ref = refactor.Refactor(self.project_root, self.filename)
+        (change,) = ref.refactor_extract_method(self.offset, 104,
+                                                "calc", False)
+        self.assertEqual(change['action'], 'change')
+        self.assertEqual(change['file'], self.filename)
+        expected = """\
+                   class Foo(object):
+                       def spaghetti(self, a, b):
+                           return self.calc(a, b)
+
+                       def calc(self, a, b):
+                           x = a + 5
+                           y = b + 23
+                           return y
+                   """
+        expected2 = expected.replace("return self.calc(a, b)",
+                                     "return self.calc(b, a)")
+        expected2 = expected2.replace("def calc(self, a, b)",
+                                      "def calc(self, b, a)")
+        # This is silly, but it's what we got.
+        if change['contents'] == dedent(expected2):
+            self.assertSourceEqual(change['contents'], expected2)
+        else:
+            self.assertSourceEqual(change['contents'], expected)
+
+    @unittest.skipIf(sys.version_info >= (3, 5), "Python 3.5 not supported")
+    def test_should_refactor_global(self):
+        ref = refactor.Refactor(self.project_root, self.filename)
+        (change,) = ref.refactor_extract_method(self.offset, 104,
+                                                "calc", True)
+        self.assertEqual(change['action'], 'change')
+        self.assertEqual(change['file'], self.filename)
+        expected = """\
+                   class Foo(object):
+                       def spaghetti(self, a, b):
+                           return calc(a, b)
+
+                   def calc(a, b):
+                       x = a + 5
+                       y = b + 23
+                       return y
+                   """
+        expected2 = expected.replace("return calc(a, b)",
+                                     "return calc(b, a)")
+        expected2 = expected2.replace("def calc(a, b)",
+                                      "def calc(b, a)")
+        if change['contents'] == dedent(expected2):
+            self.assertSourceEqual(change['contents'], expected2)
+        else:
+            self.assertSourceEqual(change['contents'], expected)
+
+
+@unittest.skipIf(not refactor.ROPE_AVAILABLE, "Requires Rope")
+class TestUseFunction(RefactorTestCase):
+    def test_should_refactor(self):
+        filename, offset = self.create_file(
+            "foo.py",
+            """\
+            def _|_add_and_multiply(a, b, c):
+                temp = a + b
+                return temp * c
+
+            f = 1 + 2
+            g = f * 3
+            """)
+
+        ref = refactor.Refactor(self.project_root, filename)
+        (change,) = ref.refactor_use_function(offset)
+
+        self.assertEqual(change['action'], 'change')
+        self.assertEqual(change['file'], filename)
+        self.assertSourceEqual(change['contents'],
+                               """\
+                               def add_and_multiply(a, b, c):
+                                   temp = a + b
+                                   return temp * c
+
+                               g = add_and_multiply(1, 2, 3)
+                               """)

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_ropebackend.py

@@ -0,0 +1,205 @@
+"""Tests for elpy.ropebackend."""
+
+import os
+import shutil
+import sys
+import tempfile
+
+import mock
+
+from elpy import ropebackend
+from elpy import rpc
+from elpy.tests import compat
+from elpy.tests.support import BackendTestCase
+from elpy.tests.support import RPCGetCompletionsTests
+from elpy.tests.support import RPCGetCompletionDocstringTests
+from elpy.tests.support import RPCGetCompletionLocationTests
+from elpy.tests.support import RPCGetDefinitionTests
+from elpy.tests.support import RPCGetCalltipTests
+from elpy.tests.support import RPCGetDocstringTests
+
+
+class RopeBackendTestCase(BackendTestCase):
+    def setUp(self):
+        super(RopeBackendTestCase, self).setUp()
+        self.backend = ropebackend.RopeBackend(self.project_root)
+
+
+class ShouldCallValidateTest(object):
+    def test_should_call_validate(self):
+        with mock.patch.object(self.backend, 'validate') as validate:
+            self.rpc(None, "", 0)
+
+            self.assertTrue(validate.called)
+
+
+class TestInit(RopeBackendTestCase):
+    def test_should_have_rope_as_name(self):
+        self.assertEqual(self.backend.name, "rope")
+
+    def test_should_patch_project_files(self):
+        self.project_file("foo.txt", "")
+        self.project_file("baddir/file.py", "")
+
+        self.backend.project.validate()
+
+        actual = [f.real_path for f in
+                  self.backend.project.file_list.get_files()]
+        self.assertEqual([os.path.join(self.project_root, "foo.txt")],
+                         actual)
+
+    def test_should_fail_for_inexisting_project_root(self):
+        with self.assertRaises(rpc.Fault):
+            ropebackend.RopeBackend("/does/not/exist/")
+
+
+class TestValidate(RopeBackendTestCase):
+    def test_should_call_validate_after_timeout(self):
+        with mock.patch("time.time") as t:
+            t.return_value = 10
+            self.backend.validate()
+            with mock.patch.object(self.backend, 'project') as project:
+                t.return_value = 10 + ropebackend.VALIDATE_EVERY_SECONDS + 1
+                self.backend.validate()
+
+                self.assertTrue(project.validate.called)
+
+    def test_should_not_call_validate_before_timeout(self):
+        with mock.patch("time.time") as t:
+            t.return_value = 10
+            self.backend.validate()
+            with mock.patch.object(self.backend, 'project') as project:
+                t.return_value = 10 + ropebackend.VALIDATE_EVERY_SECONDS - 1
+                self.backend.validate()
+
+                self.assertFalse(project.validate.called)
+
+    def test_should_not_fail_if_root_vanishes(self):
+        # Bug #353
+        tmpdir = tempfile.mkdtemp(prefix="elpy-test-validate-")
+        try:
+            backend = ropebackend.RopeBackend(tmpdir)
+        finally:
+            shutil.rmtree(tmpdir)
+        backend.validate()
+
+
+class TestRPCGetCompletions(RPCGetCompletionsTests,
+                            RopeBackendTestCase):
+    BUILTINS = ["object", "oct", "open", "or", "ord"]
+
+
+class TestRPCGetCompletionDocstring(RPCGetCompletionDocstringTests,
+                                    RopeBackendTestCase):
+    pass
+
+
+class TestRPCGetCompletionLocation(RPCGetCompletionLocationTests,
+                                   RopeBackendTestCase):
+    pass
+
+
+class TestRPCGetDefinition(RPCGetDefinitionTests,
+                           ShouldCallValidateTest,
+                           RopeBackendTestCase):
+    pass
+
+
+class TestRPCGetCalltip(RPCGetCalltipTests,
+                        ShouldCallValidateTest,
+                        RopeBackendTestCase):
+    ADD_CALLTIP = 'Add.add(a, b)'
+    RADIX_CALLTIP = "Decimal.radix()"
+    if compat.PYTHON3:
+        THREAD_CALLTIP = (
+            "threading.Thread(group=None, target=None, "
+            "name=None, args=(), kwargs=None, daemon=None, *)"
+        )
+        KEYS_CALLTIP = "builtins.keys()"
+    else:
+        THREAD_CALLTIP = (
+            "threading.Thread(group=None, target=None, "
+            "name=None, args=(), kwargs=None, verbose=None)"
+        )
+        KEYS_CALLTIP = "__builtin__.keys()"
+
+
+class TestRPCGetDocstring(RPCGetDocstringTests,
+                          ShouldCallValidateTest,
+                          RopeBackendTestCase):
+    if sys.version_info < (2, 7):
+        JSON_LOADS_DOCSTRING = (
+            'loads(s, encoding=None, cls=None, object_hook=None, '
+            'parse_float=None, parse_int=None, parse_constant=None, '
+            '**kw):'
+        )
+    else:
+        JSON_LOADS_DOCSTRING = (
+            'loads(s, encoding=None, cls=None, object_hook=None, '
+            'parse_float=None, parse_int=None, parse_constant=None, '
+            'object_pairs_hook=None, **kw):'
+        )
+
+
+class TestGetPythonProjectFiles(RopeBackendTestCase):
+    def test(self):
+        self.project_file("foo.txt", "")
+        self.project_file("gooddir/__init__.py", "")
+        self.project_file("gooddir/file.py", "")
+        self.project_file("baddir/file.py", "")
+        expected = set(os.path.join(self.project_root, name)
+                       for name in ["foo.txt", "gooddir/__init__.py",
+                                    "gooddir/file.py"])
+        project = self.backend.project
+
+        actual = set(resource.real_path
+                     for resource
+                     in ropebackend.get_python_project_files(project))
+
+        self.assertEqual(expected, actual)
+
+
+class TestPatchProjectFiles(RopeBackendTestCase):
+    def test(self):
+        self.project_file("foo.txt", "")
+        self.project_file("gooddir/__init__.py", "")
+        self.project_file("gooddir/file.py", "")
+        self.project_file("baddir/file.py", "")
+        expected = set(os.path.join(self.project_root, name)
+                       for name in ["foo.txt", "gooddir/__init__.py",
+                                    "gooddir/file.py"])
+
+        actual = set(resource.real_path
+                     for resource
+                     in self.backend.project.get_files())
+        self.assertEqual(expected, actual)
+
+
+class TestCallRope(RopeBackendTestCase):
+    def test_should_return_value(self):
+        func = mock.MagicMock()
+        func.return_value = 23
+
+        actual = self.backend.call_rope(
+            func, "foo.py", "", 0
+        )
+
+        self.assertEqual(23, actual)
+
+    def test_should_raise_fault_with_data_on_exception(self):
+        func = mock.MagicMock()
+        func.side_effect = RuntimeError("Stuff!")
+        func.__module__ = "rope.test"
+        func.__name__ = "test_function"
+
+        try:
+            self.backend.call_rope(
+                func, "foo.py", "", 0
+            )
+        except rpc.Fault as e:
+            self.assertEqual(500, e.code)
+            self.assertEqual("Stuff!", e.message)
+            self.assertIn("traceback", e.data)
+            self.assertIn("rope_debug_info", e.data)
+            self.assertEqual("rope.test.test_function",
+                             e.data["rope_debug_info"]["function_name"])

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_rpc.py

@@ -0,0 +1,209 @@
+"""Tests for elpy.rpc."""
+
+import json
+import unittest
+import sys
+
+from elpy import rpc
+from elpy.tests.compat import StringIO
+
+
+class TestFault(unittest.TestCase):
+    def test_should_have_code_and_data(self):
+        fault = rpc.Fault("Hello", code=250, data="Fnord")
+        self.assertEqual(str(fault), "Hello")
+        self.assertEqual(fault.code, 250)
+        self.assertEqual(fault.data, "Fnord")
+
+    def test_should_have_defaults_for_code_and_data(self):
+        fault = rpc.Fault("Hello")
+        self.assertEqual(str(fault), "Hello")
+        self.assertEqual(fault.code, 500)
+        self.assertIsNone(fault.data)
+
+
+class TestJSONRPCServer(unittest.TestCase):
+    def setUp(self):
+        self.stdin = StringIO()
+        self.stdout = StringIO()
+        self.rpc = rpc.JSONRPCServer(self.stdin, self.stdout)
+
+    def write(self, s):
+        self.stdin.seek(0)
+        self.stdin.truncate()
+        self.stdout.seek(0)
+        self.stdout.truncate()
+        self.stdin.write(s)
+        self.stdin.seek(0)
+
+    def read(self):
+        value = self.stdout.getvalue()
+        self.stdin.seek(0)
+        self.stdin.truncate()
+        self.stdout.seek(0)
+        self.stdout.truncate()
+        return value
+
+
+class TestInit(TestJSONRPCServer):
+    def test_should_use_arguments(self):
+        self.assertEqual(self.rpc.stdin, self.stdin)
+        self.assertEqual(self.rpc.stdout, self.stdout)
+
+    def test_should_default_to_sys(self):
+        testrpc = rpc.JSONRPCServer()
+        self.assertEqual(sys.stdin, testrpc.stdin)
+        self.assertEqual(sys.stdout, testrpc.stdout)
+
+
+class TestReadJson(TestJSONRPCServer):
+    def test_should_read_json(self):
+        objlist = [{'foo': 'bar'},
+                   {'baz': 'qux', 'fnord': 'argl\nbargl'},
+                   "beep\r\nbeep\r\nbeep"]
+        self.write("".join([(json.dumps(obj) + "\n")
+                            for obj in objlist]))
+        for obj in objlist:
+            self.assertEqual(self.rpc.read_json(),
+                             obj)
+
+    def test_should_raise_eof_on_eof(self):
+        self.assertRaises(EOFError, self.rpc.read_json)
+
+    def test_should_fail_on_malformed_json(self):
+        self.write("malformed json\n")
+        self.assertRaises(ValueError,
+                          self.rpc.read_json)
+
+
+class TestWriteJson(TestJSONRPCServer):
+    def test_should_write_json_line(self):
+        objlist = [{'foo': 'bar'},
+                   {'baz': 'qux', 'fnord': 'argl\nbargl'},
+                   ]
+        for obj in objlist:
+            self.rpc.write_json(**obj)
+            self.assertEqual(json.loads(self.read()),
+                             obj)
+
+
+class TestHandleRequest(TestJSONRPCServer):
+    def test_should_fail_if_json_does_not_contain_a_method(self):
+        self.write(json.dumps(dict(params=[],
+                                   id=23)))
+        self.assertRaises(ValueError,
+                          self.rpc.handle_request)
+
+    def test_should_call_right_method(self):
+        self.write(json.dumps(dict(method='foo',
+                                   params=[1, 2, 3],
+                                   id=23)))
+        self.rpc.rpc_foo = lambda *params: params
+        self.rpc.handle_request()
+        self.assertEqual(json.loads(self.read()),
+                         dict(id=23,
+                              result=[1, 2, 3]))
+
+    def test_should_pass_defaults_for_missing_parameters(self):
+        def test_method(*params):
+            self.args = params
+
+        self.write(json.dumps(dict(method='foo')))
+        self.rpc.rpc_foo = test_method
+        self.rpc.handle_request()
+        self.assertEqual(self.args, ())
+        self.assertEqual(self.read(), "")
+
+    def test_should_return_error_for_missing_method(self):
+        self.write(json.dumps(dict(method='foo',
+                                   id=23)))
+        self.rpc.handle_request()
+        result = json.loads(self.read())
+
+        self.assertEqual(result["id"], 23)
+        self.assertEqual(result["error"]["message"],
+                         "Unknown method foo")
+
+    def test_should_return_error_for_exception_in_method(self):
+        def test_method():
+            raise ValueError("An error was raised")
+
+        self.write(json.dumps(dict(method='foo',
+                                   id=23)))
+        self.rpc.rpc_foo = test_method
+
+        self.rpc.handle_request()
+        result = json.loads(self.read())
+
+        self.assertEqual(result["id"], 23)
+        self.assertEqual(result["error"]["message"], "An error was raised")
+        self.assertIn("traceback", result["error"]["data"])
+
+    def test_should_not_include_traceback_for_faults(self):
+        def test_method():
+            raise rpc.Fault("This is a fault")
+
+        self.write(json.dumps(dict(method="foo",
+                                   id=23)))
+        self.rpc.rpc_foo = test_method
+
+        self.rpc.handle_request()
+        result = json.loads(self.read())
+
+        self.assertEqual(result["id"], 23)
+        self.assertEqual(result["error"]["message"], "This is a fault")
+        self.assertNotIn("traceback", result["error"])
+
+    def test_should_add_data_for_faults(self):
+        def test_method():
+            raise rpc.Fault("St. Andreas' Fault",
+                            code=12345, data="Yippieh")
+
+        self.write(json.dumps(dict(method="foo", id=23)))
+        self.rpc.rpc_foo = test_method
+
+        self.rpc.handle_request()
+        result = json.loads(self.read())
+
+        self.assertEqual(result["error"]["data"], "Yippieh")
+
+    def test_should_call_handle_for_unknown_method(self):
+        def test_handle(method_name, args):
+            return "It works"
+        self.write(json.dumps(dict(method="doesnotexist",
+                                   id=23)))
+        self.rpc.handle = test_handle
+        self.rpc.handle_request()
+        self.assertEqual(json.loads(self.read()),
+                         dict(id=23,
+                              result="It works"))
+
+
+class TestServeForever(TestJSONRPCServer):
+    def handle_request(self):
+        self.hr_called += 1
+        if self.hr_called > 10:
+            raise self.error()
+
+    def setUp(self):
+        super(TestServeForever, self).setUp()
+        self.hr_called = 0
+        self.error = KeyboardInterrupt
+        self.rpc.handle_request = self.handle_request
+
+    def test_should_call_handle_request_repeatedly(self):
+        self.rpc.serve_forever()
+        self.assertEqual(self.hr_called, 11)
+
+    def test_should_return_on_some_errors(self):
+        self.error = KeyboardInterrupt
+        self.rpc.serve_forever()
+        self.error = EOFError
+        self.rpc.serve_forever()
+        self.error = SystemExit
+        self.rpc.serve_forever()
+
+    def test_should_fail_on_most_errors(self):
+        self.error = RuntimeError
+        self.assertRaises(RuntimeError,
+                          self.rpc.serve_forever)

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_server.py

@@ -0,0 +1,441 @@
+# coding: utf-8
+
+"""Tests for the elpy.server module"""
+
+import os
+import tempfile
+import unittest
+
+import mock
+
+from elpy import rpc
+from elpy import server
+from elpy.tests import compat
+from elpy.tests.support import BackendTestCase
+import elpy.refactor
+
+
+class ServerTestCase(unittest.TestCase):
+    def setUp(self):
+        self.srv = server.ElpyRPCServer()
+
+
+class BackendCallTestCase(ServerTestCase):
+    def assert_calls_backend(self, method):
+        with mock.patch("elpy.server.get_source") as get_source:
+            with mock.patch.object(self.srv, "backend") as backend:
+                get_source.return_value = "transformed source"
+
+                getattr(self.srv, method)("filename", "source", "offset")
+
+                get_source.assert_called_with("source")
+                getattr(backend, method).assert_called_with(
+                    "filename", "transformed source", "offset"
+                )
+
+
+class TestInit(ServerTestCase):
+    def test_should_not_select_a_backend_by_default(self):
+        self.assertIsNone(self.srv.backend)
+
+
+class TestRPCEcho(ServerTestCase):
+    def test_should_return_arguments(self):
+        self.assertEqual(("hello", "world"),
+                         self.srv.rpc_echo("hello", "world"))
+
+
+class TestRPCInit(ServerTestCase):
+    @mock.patch("elpy.jedibackend.JediBackend")
+    @mock.patch("elpy.ropebackend.RopeBackend")
+    def test_should_set_project_root(self, RopeBackend, JediBackend):
+        self.srv.rpc_init({"project_root": "/project/root",
+                           "backend": "rope"})
+
+        self.assertEqual("/project/root", self.srv.project_root)
+
+    @mock.patch("elpy.jedibackend.JediBackend")
+    @mock.patch("elpy.ropebackend.RopeBackend")
+    def test_should_initialize_rope(self, RopeBackend, JediBackend):
+        self.srv.rpc_init({"project_root": "/project/root",
+                           "backend": "rope"})
+
+        RopeBackend.assert_called_with("/project/root")
+
+    @mock.patch("elpy.jedibackend.JediBackend")
+    @mock.patch("elpy.ropebackend.RopeBackend")
+    def test_should_initialize_jedi(self, RopeBackend, JediBackend):
+        self.srv.rpc_init({"project_root": "/project/root",
+                           "backend": "jedi"})
+
+        JediBackend.assert_called_with("/project/root")
+
+    @mock.patch("elpy.jedibackend.JediBackend")
+    @mock.patch("elpy.ropebackend.RopeBackend")
+    def test_should_use_rope_if_available_and_requested(
+            self, RopeBackend, JediBackend):
+        RopeBackend.return_value.name = "rope"
+        JediBackend.return_value.name = "jedi"
+
+        self.srv.rpc_init({"project_root": "/project/root",
+                           "backend": "rope"})
+
+        self.assertEqual("rope", self.srv.backend.name)
+
+    @mock.patch("elpy.jedibackend.JediBackend")
+    @mock.patch("elpy.ropebackend.RopeBackend")
+    def test_should_use_jedi_if_available_and_requested(
+            self, RopeBackend, JediBackend):
+        RopeBackend.return_value.name = "rope"
+        JediBackend.return_value.name = "jedi"
+
+        self.srv.rpc_init({"project_root": "/project/root",
+                           "backend": "jedi"})
+
+        self.assertEqual("jedi", self.srv.backend.name)
+
+    @mock.patch("elpy.jedibackend.JediBackend")
+    @mock.patch("elpy.ropebackend.RopeBackend")
+    def test_should_use_rope_if_available_and_nothing_requested(
+            self, RopeBackend, JediBackend):
+        RopeBackend.return_value.name = "rope"
+        JediBackend.return_value.name = "jedi"
+
+        self.srv.rpc_init({"project_root": "/project/root",
+                           "backend": None})
+
+        self.assertEqual("rope", self.srv.backend.name)
+
+    @mock.patch("elpy.jedibackend.JediBackend")
+    @mock.patch("elpy.ropebackend.RopeBackend")
+    def test_should_use_jedi_if_rope_not_available_and_nothing_requested(
+            self, RopeBackend, JediBackend):
+        RopeBackend.return_value.name = "rope"
+        JediBackend.return_value.name = "jedi"
+        old_rope = server.ropebackend
+        server.ropebackend = None
+
+        try:
+            self.srv.rpc_init({"project_root": "/project/root",
+                               "backend": None})
+        finally:
+            server.ropebackend = old_rope
+
+        self.assertEqual("jedi", self.srv.backend.name)
+
+    @mock.patch("elpy.jedibackend.JediBackend")
+    @mock.patch("elpy.ropebackend.RopeBackend")
+    def test_should_use_none_if_nothing_available(
+            self, RopeBackend, JediBackend):
+        RopeBackend.return_value.name = "rope"
+        JediBackend.return_value.name = "jedi"
+        old_rope = server.ropebackend
+        old_jedi = server.jedibackend
+        server.ropebackend = None
+        server.jedibackend = None
+
+        try:
+            self.srv.rpc_init({"project_root": "/project/root",
+                               "backend": None})
+        finally:
+            server.ropebackend = old_rope
+            server.jedibackend = old_jedi
+
+        self.assertIsNone(self.srv.backend)
+
+
+class TestRPCGetCalltip(BackendCallTestCase):
+    def test_should_call_backend(self):
+        self.assert_calls_backend("rpc_get_calltip")
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        self.assertIsNone(self.srv.rpc_get_calltip("filname", "source",
+                                                   "offset"))
+
+
+class TestRPCGetCompletions(BackendCallTestCase):
+    def test_should_call_backend(self):
+        self.assert_calls_backend("rpc_get_completions")
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        self.assertEqual([],
+                         self.srv.rpc_get_completions("filname", "source",
+                                                      "offset"))
+
+    def test_should_sort_results(self):
+        with mock.patch.object(self.srv, 'backend') as backend:
+            backend.rpc_get_completions.return_value = [
+                {'name': '_e'},
+                {'name': '__d'},
+                {'name': 'c'},
+                {'name': 'B'},
+                {'name': 'a'},
+            ]
+            expected = list(reversed(backend.rpc_get_completions.return_value))
+
+            actual = self.srv.rpc_get_completions("filename", "source",
+                                                  "offset")
+
+            self.assertEqual(expected, actual)
+
+    def test_should_uniquify_results(self):
+        with mock.patch.object(self.srv, 'backend') as backend:
+            backend.rpc_get_completions.return_value = [
+                {'name': 'a'},
+                {'name': 'a'},
+            ]
+            expected = [{'name': 'a'}]
+
+            actual = self.srv.rpc_get_completions("filename", "source",
+                                                  "offset")
+
+            self.assertEqual(expected, actual)
+
+
+class TestRPCGetCompletionDocs(ServerTestCase):
+    def test_should_call_backend(self):
+        with mock.patch.object(self.srv, "backend") as backend:
+            self.srv.rpc_get_completion_docstring("completion")
+
+            (backend.rpc_get_completion_docstring
+             .assert_called_with("completion"))
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        self.assertIsNone(self.srv.rpc_get_completion_docstring("foo"))
+
+
+class TestRPCGetCompletionLocation(ServerTestCase):
+    def test_should_call_backend(self):
+        with mock.patch.object(self.srv, "backend") as backend:
+            self.srv.rpc_get_completion_location("completion")
+
+            (backend.rpc_get_completion_location
+             .assert_called_with("completion"))
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        self.assertIsNone(self.srv.rpc_get_completion_location("foo"))
+
+
+class TestRPCGetDefinition(BackendCallTestCase):
+    def test_should_call_backend(self):
+        self.assert_calls_backend("rpc_get_definition")
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        self.assertIsNone(self.srv.rpc_get_definition("filname", "source",
+                                                      "offset"))
+
+
+class TestRPCGetAssignment(BackendCallTestCase):
+    def test_should_call_backend(self):
+        self.assert_calls_backend("rpc_get_assignment")
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        self.assertIsNone(self.srv.rpc_get_assignment("filname", "source",
+                                                      "offset"))
+
+
+class TestRPCGetDocstring(BackendCallTestCase):
+    def test_should_call_backend(self):
+        self.assert_calls_backend("rpc_get_docstring")
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        self.assertIsNone(self.srv.rpc_get_docstring("filname", "source",
+                                                     "offset"))
+
+
+class TestRPCGetPydocCompletions(ServerTestCase):
+    @mock.patch.object(server, 'get_pydoc_completions')
+    def test_should_call_pydoc_completions(self, get_pydoc_completions):
+        srv = server.ElpyRPCServer()
+        srv.rpc_get_pydoc_completions()
+        get_pydoc_completions.assert_called_with(None)
+        srv.rpc_get_pydoc_completions("foo")
+        get_pydoc_completions.assert_called_with("foo")
+
+
+class TestGetPydocDocumentation(ServerTestCase):
+    @mock.patch("pydoc.render_doc")
+    def test_should_find_documentation(self, render_doc):
+        render_doc.return_value = "expected"
+
+        actual = self.srv.rpc_get_pydoc_documentation("open")
+
+        render_doc.assert_called_with("open",
+                                      "Elpy Pydoc Documentation for %s",
+                                      False)
+        self.assertEqual("expected", actual)
+
+    def test_should_return_none_for_unknown_module(self):
+        actual = self.srv.rpc_get_pydoc_documentation("frob.open")
+
+        self.assertIsNone(actual)
+
+    def test_should_return_valid_unicode(self):
+        import json
+
+        docstring = self.srv.rpc_get_pydoc_documentation("tarfile")
+
+        json.dumps(docstring)
+
+
+class TestRPCGetRefactorOptions(BackendTestCase):
+    @mock.patch.object(compat.builtins, '__import__')
+    def test_should_fail_if_rope_is_not_available(self, import_):
+        import_.side_effect = ImportError
+        filename = self.project_file("foo.py", "")
+        srv = server.ElpyRPCServer()
+        self.assertRaises(ImportError, srv.rpc_get_refactor_options,
+                          filename, 0)
+
+    @mock.patch.object(elpy.refactor, 'Refactor')
+    def test_should_initialize_and_call_refactor_object(self, Refactor):
+        filename = self.project_file("foo.py", "import foo")
+        srv = server.ElpyRPCServer()
+        srv.project_root = self.project_root
+
+        srv.rpc_get_refactor_options(filename, 5)
+
+        Refactor.assert_called_with(self.project_root, filename)
+        Refactor.return_value.get_refactor_options.assert_called_with(5, None)
+
+
+class TestRPCRefactor(BackendTestCase):
+    @mock.patch.object(compat.builtins, '__import__')
+    def test_should_fail_if_rope_is_not_available(self, import_):
+        import_.side_effect = ImportError
+        filename = self.project_file("foo.py", "")
+        srv = server.ElpyRPCServer()
+        self.assertRaises(ImportError, srv.rpc_refactor,
+                          filename, 'foo', ())
+
+    @mock.patch.object(elpy.refactor, 'Refactor')
+    def test_should_initialize_and_call_refactor_object_with_args(
+            self, Refactor):
+        filename = self.project_file("foo.py", "import foo")
+        srv = server.ElpyRPCServer()
+        srv.project_root = self.project_root
+
+        srv.rpc_refactor(filename, 'foo', (1, 2, 3))
+
+        Refactor.assert_called_with(self.project_root, filename)
+        Refactor.return_value.get_changes.assert_called_with('foo', 1, 2, 3)
+
+    @mock.patch.object(elpy.refactor, 'Refactor')
+    def test_should_initialize_and_call_refactor_object_without_args(
+            self, Refactor):
+        filename = self.project_file("foo.py", "import foo")
+        srv = server.ElpyRPCServer()
+        srv.project_root = self.project_root
+
+        srv.rpc_refactor(filename, 'foo', None)
+
+        Refactor.assert_called_with(self.project_root, filename)
+        Refactor.return_value.get_changes.assert_called_with('foo')
+
+
+class TestRPCGetUsages(BackendCallTestCase):
+    def test_should_call_backend(self):
+        self.assert_calls_backend("rpc_get_usages")
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        with self.assertRaises(rpc.Fault):
+            self.assertIsNone(self.srv.rpc_get_usages("filname", "source",
+                                                      "offset"))
+
+
+class TestRPCGetNames(BackendCallTestCase):
+    def test_should_call_backend(self):
+        self.assert_calls_backend("rpc_get_names")
+
+    def test_should_handle_no_backend(self):
+        self.srv.backend = None
+        with self.assertRaises(rpc.Fault):
+            self.assertIsNone(self.srv.rpc_get_names("filname", "source", 0))
+
+
+class TestRPCImportMagic(ServerTestCase):
+    def test_should_call_importmagic(self):
+        with mock.patch.object(self.srv, "import_magic") as impmagic:
+            self.srv.rpc_get_import_symbols("filename", "source", "os")
+            impmagic.get_import_symbols.assert_called_with("os")
+            self.srv.rpc_add_import("filename", "source", "import os")
+            impmagic.add_import.assert_called_with("source", "import os")
+            self.srv.rpc_get_unresolved_symbols("filename", "source")
+            impmagic.get_unresolved_symbols.assert_called_with("source")
+            self.srv.rpc_remove_unreferenced_imports("filename", "source")
+            impmagic.remove_unreferenced_imports.assert_called_with("source")
+
+
+class TestGetSource(unittest.TestCase):
+    def test_should_return_string_by_default(self):
+        self.assertEqual(server.get_source("foo"),
+                         "foo")
+
+    def test_should_return_file_contents(self):
+        fd, filename = tempfile.mkstemp(prefix="elpy-test-")
+        self.addCleanup(os.remove, filename)
+        with open(filename, "w") as f:
+            f.write("file contents")
+
+        fileobj = {'filename': filename}
+
+        self.assertEqual(server.get_source(fileobj),
+                         "file contents")
+
+    def test_should_clean_up_tempfile(self):
+        fd, filename = tempfile.mkstemp(prefix="elpy-test-")
+        with open(filename, "w") as f:
+            f.write("file contents")
+
+        fileobj = {'filename': filename,
+                   'delete_after_use': True}
+
+        self.assertEqual(server.get_source(fileobj),
+                         "file contents")
+        self.assertFalse(os.path.exists(filename))
+
+    def test_should_support_utf8(self):
+        fd, filename = tempfile.mkstemp(prefix="elpy-test-")
+        self.addCleanup(os.remove, filename)
+        with open(filename, "wb") as f:
+            f.write(u"möp".encode("utf-8"))
+
+        source = server.get_source({'filename': filename})
+
+        self.assertEqual(source, u"möp")
+
+
+class TestPysymbolKey(BackendTestCase):
+    def keyLess(self, a, b):
+        self.assertLess(b, a)
+        self.assertLess(server._pysymbol_key(a),
+                        server._pysymbol_key(b))
+
+    def test_should_be_case_insensitive(self):
+        self.keyLess("bar", "Foo")
+
+    def test_should_sort_private_symbols_after_public_symbols(self):
+        self.keyLess("foo", "_bar")
+
+    def test_should_sort_private_symbols_after_dunder_symbols(self):
+        self.assertLess(server._pysymbol_key("__foo__"),
+                        server._pysymbol_key("_bar"))
+
+    def test_should_sort_dunder_symbols_after_public_symbols(self):
+        self.keyLess("bar", "__foo")
+
+
+class Autopep8TestCase(ServerTestCase):
+
+    def test_rpc_fix_code_should_return_formatted_string(self):
+        code_block = 'x=       123\n'
+        new_block = self.srv.rpc_fix_code(code_block)
+        self.assertEqual(new_block, 'x = 123\n')

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_support.py

@@ -0,0 +1,19 @@
+"""Tests for elpy.tests.support. Yep, we test test code."""
+
+import unittest
+
+from elpy.tests.support import source_and_offset
+
+
+class TestSourceAndOffset(unittest.TestCase):
+    def test_should_return_source_and_offset(self):
+        self.assertEqual(source_and_offset("hello, _|_world"),
+                         ("hello, world", 7))
+
+    def test_should_handle_beginning_of_string(self):
+        self.assertEqual(source_and_offset("_|_hello, world"),
+                         ("hello, world", 0))
+
+    def test_should_handle_end_of_string(self):
+        self.assertEqual(source_and_offset("hello, world_|_"),
+                         ("hello, world", 12))

.emacs.d/elpa/elpy-20171206.847/elpy/tests/test_yapf.py

@@ -0,0 +1,32 @@
+# coding: utf-8
+"""Tests for the elpy.yapf module"""
+
+import unittest
+
+from elpy import yapfutil
+from elpy.rpc import Fault
+from elpy.tests.support import BackendTestCase
+
+
+@unittest.skipIf(yapfutil.YAPF_NOT_SUPPORTED,
+                 'yapf not supported for current python version')
+class YAPFTestCase(BackendTestCase):
+    def setUp(self):
+        if yapfutil.YAPF_NOT_SUPPORTED:
+            raise unittest.SkipTest
+
+    def test_fix_code_should_throw_error_for_invalid_code(self):
+        src = 'x = '
+        self.assertRaises(Fault, yapfutil.fix_code, src)
+
+    def test_fix_code(self):
+        testdata = [
+            ('x=       123\n', 'x = 123\n'),
+            ('x=1; \ny=2 \n', 'x = 1\ny = 2\n'),
+        ]
+        for src, expected in testdata:
+            self._assert_format(src, expected)
+
+    def _assert_format(self, src, expected):
+        new_block = yapfutil.fix_code(src)
+        self.assertEqual(new_block, expected)

.emacs.d/elpa/elpy-20171206.847/elpy/yapfutil.py

@@ -0,0 +1,38 @@
+"""Glue for the "yapf" library.
+
+"""
+
+import os
+import sys
+
+from elpy.rpc import Fault
+
+YAPF_NOT_SUPPORTED = sys.version_info < (2, 7) or (
+    sys.version_info >= (3, 0) and sys.version_info < (3, 4))
+
+try:
+    if YAPF_NOT_SUPPORTED:
+        yapf_api = None
+    else:
+        from yapf.yapflib import yapf_api
+        from yapf.yapflib import file_resources
+except ImportError:  # pragma: no cover
+    yapf_api = None
+
+
+def fix_code(code):
+    """Formats Python code to conform to the PEP 8 style guide.
+
+    """
+    if not yapf_api:
+        raise Fault('yapf not installed', code=400)
+    style_config = file_resources.GetDefaultStyleForDir(os.getcwd())
+    try:
+        reformatted_source, _ = yapf_api.FormatCode(code,
+                                                    filename='<stdin>',
+                                                    style_config=style_config,
+                                                    verify=False)
+        return reformatted_source
+    except Exception as e:
+            raise Fault("Error during formatting: {}".format(e),
+                        code=400)

.emacs.d/elpa/elpy-20171206.847/snippets/python-mode/.yas-setup.el

@@ -0,0 +1,68 @@
+(defun elpy-snippet-split-args (arg-string)
+  "Split a python argument string into ((name, default)..) tuples"
+  (mapcar (lambda (x)
+            (split-string x "[[:blank:]]*=[[:blank:]]*" t))
+          (split-string arg-string "[[:blank:]]*,[[:blank:]]*" t)))
+
+(defun elpy-snippet-current-method-and-args ()
+  "Return information on the current definition."
+  (let ((current-defun (python-info-current-defun))
+        (current-arglist
+         (save-excursion
+           (python-nav-beginning-of-defun)
+           (when (re-search-forward "(" nil t)
+             (let* ((start (point))
+                    (end (progn
+                           (forward-char -1)
+                           (forward-sexp)
+                           (- (point) 1))))
+               (elpy-snippet-split-args
+                (buffer-substring-no-properties start end))))))
+        class method args)
+    (when (not current-arglist)
+      (setq current-arglist '(("self"))))
+    (if (and current-defun
+             (string-match "^\\(.*\\)\\.\\(.*\\)$" current-defun))
+        (setq class (match-string 1 current-defun)
+              method (match-string 2 current-defun))
+      (setq class "Class"
+            method "method"))
+    (setq args (mapcar #'car current-arglist))
+    (list class method args)))
+
+(defun elpy-snippet-init-assignments (arg-string)
+  "Return the typical __init__ assignments for arguments."
+  (let ((indentation (make-string (save-excursion
+                                    (goto-char start-point)
+                                    (current-indentation))
+                                  ?\s)))
+    (mapconcat (lambda (arg)
+                 (if (string-match "^\\*" (car arg))
+                     ""
+                   (format "self.%s = %s\n%s"
+                           (car arg)
+                           (car arg)
+                           indentation)))
+               (elpy-snippet-split-args arg-string)
+               "")))
+
+(defun elpy-snippet-super-form ()
+  "Return (Class, first-arg).method if Py2.
+Else return ().method for Py3."
+  (let* ((defun-info (elpy-snippet-current-method-and-args))
+         (class (nth 0 defun-info))
+         (method (nth 1 defun-info))
+         (args (nth 2 defun-info))
+         (first-arg (nth 0 args))
+         (py-version-command " -c 'import sys ; print(sys.version_info.major)'")
+         ;; Get the python version. Either 2 or 3
+         (py-version-num (substring (shell-command-to-string (concat elpy-rpc-python-command py-version-command))0 1)))
+    (if (string-match py-version-num "2")
+        (format "(%s, %s).%s" class first-arg method)
+      (format "().%s" method))))
+
+(defun elpy-snippet-super-arguments ()
+  "Return the argument list for the current method."
+  (mapconcat (lambda (x) x)
+             (cdr (nth 2 (elpy-snippet-current-method-and-args)))
+             ", "))

.emacs.d/elpa/elpy-20171206.847/snippets/python-mode/__abs__

@@ -0,0 +1,7 @@
+# -*- mode: snippet -*-
+# name: __abs__
+# key: __abs__
+# group: Special methods
+# --
+def __abs__(self):
+    return $0

.emacs.d/elpa/elpy-20171206.847/snippets/python-mode/__add__

@@ -0,0 +1,7 @@
+# -*- mode: snippet -*-
+# name: __add__
+# key: __add__
+# group: Special methods
+# --
+def __add__(self, other):
+    return $0

.emacs.d/elpa/elpy-20171206.847/snippets/python-mode/__and__

@@ -0,0 +1,7 @@
+# -*- mode: snippet -*-
+# name: __and__
+# key: __and__
+# group: Special methods
+# --
+def __and__(self, other):
+    return $0

.emacs.d/elpa/elpy-20171206.847/snippets/python-mode/__bool__

@@ -0,0 +1,7 @@
+# -*- mode: snippet -*-
+# name: __bool__
+# key: __bool__
+# group: Special methods
+# --
+def __bool__(self):
+    return $0

.emacs.d/elpa/elpy-20171206.847/snippets/python-mode/__call__

@@ -0,0 +1,7 @@
+# -*- mode: snippet -*-
+# name: __call__
+# key: __call__
+# group: Special methods
+# --
+def __call__(self, ${1:*args}):
+    return $0