about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/quelpa-20180907.2232/quelpa.el
diff options
context:
space:
mode:
authorWilliam Carroll <wpcarro@gmail.com>2019-01-13T19·33-0500
committerWilliam Carroll <wpcarro@gmail.com>2019-01-13T19·45-0500
commit481df5a3855ccd5ea3bf4d5f41ae780f4773b7b4 (patch)
tree3aeb7e20eaba176536cb8d10ba531ac39674fc4a /configs/shared/emacs/.emacs.d/elpa/quelpa-20180907.2232/quelpa.el
parent18b9930b8604134f087ca61fe94740b31f94327c (diff)
Remove Emacs spam
My inconsistent git history-keeping is coming to bite me here. At the
moment, I can only speculate about what went wrong here. The gist is
this: I unintentionally committed files that were supposed to be ignored

This commit removes those files which includes:

- auto-save-list
- elpa packages
- quelpa packages
- misc
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/quelpa-20180907.2232/quelpa.el')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/quelpa-20180907.2232/quelpa.el1799
1 files changed, 0 insertions, 1799 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/quelpa-20180907.2232/quelpa.el b/configs/shared/emacs/.emacs.d/elpa/quelpa-20180907.2232/quelpa.el
deleted file mode 100644
index 0994a7cf768d..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/quelpa-20180907.2232/quelpa.el
+++ /dev/null
@@ -1,1799 +0,0 @@
-;;; quelpa.el --- Emacs Lisp packages built directly from source
-
-;; Copyright 2014-2018, Steckerhalter
-;; Copyright 2014-2015, Vasilij Schneidermann <v.schneidermann@gmail.com>
-
-;; Author: steckerhalter
-;; URL: https://framagit.org/steckerhalter/quelpa
-;; Version: 0.0.1
-;; Package-Requires: ((emacs "24.3"))
-;; Keywords: package management build source elpa
-
-;; This file is not part of GNU Emacs.
-
-;; This file is free software; you can redistribute it and/or modify
-;; it under the terms of the GNU General Public License as published by
-;; the Free Software Foundation; either version 3, or (at your option)
-;; any later version.
-
-;; This file is distributed in the hope that it will be useful,
-;; but WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-;; GNU General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to
-;; the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
-
-;;; Commentary:
-
-;; Your personal local Emacs Lisp Package Archive (ELPA) with packages
-;; built on-the-fly directly from source.
-
-;; See the README for more info:
-;; https://framagit.org/steckerhalter/quelpa/blob/master/README.md
-
-;;; Requirements:
-
-;; Emacs 24.3.1
-
-;;; Code:
-
-(require 'cl-lib)
-(require 'help-fns)
-(require 'url-parse)
-(require 'package)
-(require 'lisp-mnt)
-
-;; --- customs / variables ---------------------------------------------------
-
-(defgroup quelpa nil
-  "Build and install packages from source code"
-  :group 'package)
-
-(defcustom quelpa-upgrade-p nil
-  "When non-nil, `quelpa' will try to upgrade packages.
-The global value can be overridden for each package by supplying
-the `:upgrade' argument."
-  :group 'quelpa
-  :type 'boolean)
-
-(defcustom quelpa-stable-p nil
-  "When non-nil, try to build stable packages like MELPA does."
-  :group 'quelpa
-  :type 'boolean)
-
-(defcustom quelpa-verbose t
-  "When non-nil, `quelpa' prints log messages."
-  :group 'quelpa
-  :type 'boolean)
-
-(defcustom quelpa-before-hook nil
-  "List of functions to be called before quelpa."
-  :group 'quelpa
-  :type 'hook)
-
-(defcustom quelpa-after-hook nil
-  "List of functions to be called after quelpa."
-  :group 'quelpa
-  :type 'hook)
-
-(defcustom quelpa-dir (expand-file-name "quelpa" user-emacs-directory)
-  "Where quelpa builds and stores packages."
-  :group 'quelpa
-  :type 'string)
-
-(defcustom quelpa-melpa-dir (expand-file-name "melpa" quelpa-dir)
-  "Where the melpa repo cloned to."
-  :group 'quelpa
-  :type 'string)
-
-(defcustom quelpa-build-dir (expand-file-name "build" quelpa-dir)
-  "Where quelpa builds packages."
-  :group 'quelpa
-  :type 'string)
-
-(defcustom quelpa-packages-dir (expand-file-name "packages" quelpa-dir)
-  "Where quelpa puts built packages."
-  :group 'quelpa
-  :type 'string)
-
-(defcustom quelpa-melpa-recipe-stores (list (expand-file-name
-                                             "recipes"
-                                             quelpa-melpa-dir))
-  "Recipe stores where quelpa finds default recipes for packages.
-A store can either be a string pointing to a directory with
-recipe files or a list with recipes."
-  :group 'quelpa
-  :type '(repeat
-          (choice directory
-                  (repeat
-                   :tag "List of recipes"
-                   (restricted-sexp :tag "Recipe"
-                                    :match-alternatives (listp))))))
-
-(defcustom quelpa-persistent-cache-file (expand-file-name "cache" quelpa-dir)
-  "Location of the persistent cache file."
-  :group 'quelpa
-  :type 'string)
-
-(defcustom quelpa-persistent-cache-p t
-  "Non-nil when quelpa's cache is saved on and read from disk."
-  :group 'quelpa
-  :type 'boolean)
-
-(defcustom quelpa-checkout-melpa-p t
-  "If non-nil the MELPA git repo is cloned when quelpa is initialized."
-  :group 'quelpa
-  :type 'boolean)
-
-(defcustom quelpa-update-melpa-p t
-  "If non-nil the MELPA git repo is updated when quelpa is initialized.
-If nil the update is disabled and the repo is only updated on
-`quelpa-upgrade' or `quelpa-self-upgrade'."
-  :group 'quelpa
-  :type 'boolean)
-
-(defcustom quelpa-melpa-repo-url "https://github.com/melpa/melpa.git"
-  "The melpa git repository url."
-  :group 'quelpa
-  :type 'string)
-
-(defcustom quelpa-self-upgrade-p t
-  "If non-nil upgrade quelpa itself when doing a
-  `quelpa-upgrade', otherwise only upgrade the packages in the
-  quelpa cache."
-  :group 'quelpa
-  :type 'boolean)
-
-(defvar quelpa-initialized-p nil
-  "Non-nil when quelpa has been initialized.")
-
-(defvar quelpa-cache nil
-  "The `quelpa' command stores processed pkgs/recipes in the cache.")
-
-(defvar quelpa-recipe '(quelpa :url "https://framagit.org/steckerhalter/quelpa.git" :fetcher git)
-  "The recipe for quelpa.")
-
-;; --- compatibility for legacy `package.el' in Emacs 24.3  -------------------
-
-(defun quelpa-setup-package-structs ()
-  "Setup the struct `package-desc' when not available.
-`package-desc-from-legacy' is provided to convert the legacy
-vector desc into a valid PACKAGE-DESC."
-  (unless (functionp 'package-desc-p)
-    (cl-defstruct
-        (package-desc
-         (:constructor
-          ;; convert legacy package desc into PACKAGE-DESC
-          package-desc-from-legacy
-          (pkg-info kind
-                    &aux
-                    (name (intern (aref pkg-info 0)))
-                    (version (version-to-list (aref pkg-info 3)))
-                    (summary (if (string= (aref pkg-info 2) "")
-                                 "No description available."
-                               (aref pkg-info 2)))
-                    (reqs  (aref pkg-info 1))
-                    (kind kind))))
-      name
-      version
-      (summary "No description available.")
-      reqs
-      kind
-      archive
-      dir
-      extras
-      signed)))
-
-;; --- package building ------------------------------------------------------
-
-(defun quelpa-package-type (file)
-  "Determine the package type of FILE.
-Return `tar' for tarball packages, `single' for single file
-packages, or nil, if FILE is not a package."
-  (let ((ext (file-name-extension file)))
-    (cond
-     ((string= ext "tar") 'tar)
-     ((string= ext "el") 'single)
-     (:else nil))))
-
-(defun quelpa-get-package-desc (file)
-  "Extract and return the PACKAGE-DESC struct from FILE.
-On error return nil."
-  (let* ((kind (quelpa-package-type file))
-         (desc (with-demoted-errors "Error getting PACKAGE-DESC: %s"
-                 (with-temp-buffer
-                   (pcase kind
-                     (`single (insert-file-contents file)
-                              (package-buffer-info))
-                     (`tar (insert-file-contents-literally file)
-                           (tar-mode)
-                           (if (help-function-arglist 'package-tar-file-info)
-                               ;; legacy `package-tar-file-info' requires an arg
-                               (package-tar-file-info file)
-                             (with-no-warnings (package-tar-file-info)))))))))
-    (pcase desc
-      ((pred package-desc-p) desc)
-      ((pred vectorp) (package-desc-from-legacy desc kind)))))
-
-(defun quelpa-archive-file-name (archive-entry)
-  "Return the path of the file in which the package for ARCHIVE-ENTRY is stored."
-  (let* ((name (car archive-entry))
-         (pkg-info (cdr archive-entry))
-         (version (package-version-join (aref pkg-info 0)))
-         (flavour (aref pkg-info 3)))
-    (expand-file-name
-     (format "%s-%s.%s" name version (if (eq flavour 'single) "el" "tar"))
-     quelpa-packages-dir)))
-
-(defun quelpa-version>-p (name version)
-  "Return non-nil if VERSION of pkg with NAME is newer than what is currently installed."
-  (not (or (not version)
-           (let ((pkg-desc (cdr (assq name package-alist))))
-             (and pkg-desc
-                  (version-list-<=
-                   (version-to-list version)
-                   (if (functionp 'package-desc-vers)
-                       (package-desc-vers pkg-desc) ;old implementation
-                     (package-desc-version (car pkg-desc))))))
-           ;; Also check built-in packages.
-           (package-built-in-p name (version-to-list version)))))
-
-(defun quelpa-checkout (rcp dir)
-  "Return the version of the new package given a RCP.
-Return nil if the package is already installed and should not be upgraded."
-  (pcase-let ((`(,name . ,config) rcp)
-              (quelpa-build-stable quelpa-stable-p))
-    (unless (or (and (assq name package-alist) (not quelpa-upgrade-p))
-                (and (not config)
-                     (quelpa-message t "no recipe found for package `%s'" name)))
-      (let ((version (condition-case err
-                         (quelpa-build-checkout name config dir)
-                       (error "Failed to checkout `%s': `%s'"
-                              name (error-message-string err)))))
-        (when (quelpa-version>-p name version)
-          version)))))
-
-(defun quelpa-build (rcp)
-  "Build a package from the given recipe RCP.
-Uses the `package-build' library to get the source code and build
-an elpa compatible package in `quelpa-build-dir' storing it in
-`quelpa-packages-dir'. Return the path to the created file or nil
-if no action is necessary (like when the package is installed
-already and should not be upgraded etc)."
-  (let* ((name (car rcp))
-         (build-dir (expand-file-name (symbol-name name) quelpa-build-dir))
-         (version (quelpa-checkout rcp build-dir)))
-    (when version
-      (quelpa-archive-file-name
-       (quelpa-build-package (symbol-name name)
-                             version
-                             (quelpa-build--config-file-list (cdr rcp))
-                             build-dir
-                             quelpa-packages-dir)))))
-
-;; --- package-build.el integration ------------------------------------------
-
-(defun quelpa-file-version (file-path type version time-stamp)
-  "Return version of file at FILE-PATH."
-  (if (eq type 'directory)
-      time-stamp
-    (cl-letf* ((package-strip-rcs-id-orig (symbol-function 'package-strip-rcs-id))
-               ((symbol-function 'package-strip-rcs-id)
-                (lambda (str)
-                  (or (funcall package-strip-rcs-id-orig (lm-header "package-version"))
-                      (funcall package-strip-rcs-id-orig (lm-header "version"))
-                      "0"))))
-      (concat (mapconcat
-               #'number-to-string
-               (package-desc-version (quelpa-get-package-desc file-path)) ".")
-              (pcase version
-                (`original "")
-                (_ (concat "pre0." time-stamp)))))))
-
-(defun quelpa-directory-files (path)
-  "Return list of directory files from PATH recursively."
-  (let ((result '()))
-    (mapc
-     (lambda (file)
-       (if (file-directory-p file)
-           (progn
-             ;; When directory is not empty.
-             (when (cddr (directory-files file))
-               (dolist (subfile (quelpa-directory-files file))
-                 (add-to-list 'result subfile))))
-         (add-to-list 'result file)))
-     (mapcar
-      (lambda (file) (expand-file-name file path))
-      ;; Without first two entries because they are always "." and "..".
-      (cddr (directory-files path))))
-    result))
-
-(defun quelpa-expand-source-file-list (file-path config)
-  "Return list of source files from FILE-PATH corresponding to
-CONFIG."
-  (let ((source-files
-         (mapcar
-          (lambda (file) (expand-file-name file file-path))
-          (quelpa-build--expand-source-file-list file-path config))))
-    ;; Replace any directories in the source file list with the filenames of the
-    ;; files they contain (so that these files can subsequently be hashed).
-    (dolist (file source-files source-files)
-      (when (file-directory-p file)
-        (setq source-files (remove file source-files))
-        (setq source-files (append source-files
-                                   (quelpa-directory-files file)))))))
-
-(defun quelpa-slurp-file (file)
-  "Return the contents of FILE as a string, or nil if no such
-file exists."
-  (when (file-exists-p file)
-    (with-temp-buffer
-      (set-buffer-multibyte nil)
-      (setq-local buffer-file-coding-system 'binary)
-      (insert-file-contents-literally file)
-      (buffer-substring-no-properties (point-min) (point-max)))))
-
-(defun quelpa-check-hash (name config file-path dir &optional fetcher)
-  "Check if hash of FILE-PATH is different as in STAMP-FILE.
-If it is different save the new hash and timestamp to STAMP-FILE
-and return TIME-STAMP, otherwise return OLD-TIME-STAMP."
-  (unless (file-directory-p dir)
-    (make-directory dir))
-  (let* (files
-         hashes
-         new-stamp-info
-         new-content-hash
-         (time-stamp
-          (replace-regexp-in-string "\\.0+" "." (format-time-string "%Y%m%d.%H%M%S")))
-         (stamp-file (concat (expand-file-name (symbol-name name) dir) ".stamp"))
-         (old-stamp-info (quelpa-build--read-from-file stamp-file))
-         (old-content-hash (cdr old-stamp-info))
-         (old-time-stamp (car old-stamp-info))
-         (type (if (file-directory-p file-path) 'directory 'file))
-         (version (plist-get config :version)))
-
-    (if (not (file-exists-p file-path))
-        (error "`%s' does not exist" file-path)
-      (if (eq type 'directory)
-          (setq files (quelpa-expand-source-file-list file-path config)
-                hashes (mapcar
-                        (lambda (file)
-                          (secure-hash
-                           'sha1 (concat file (quelpa-slurp-file file)))) files)
-                new-content-hash (secure-hash 'sha1 (mapconcat 'identity hashes "")))
-        (setq new-content-hash (secure-hash 'sha1 (quelpa-slurp-file file-path)))))
-
-    (setq new-stamp-info (cons time-stamp new-content-hash))
-    (if (and old-content-hash
-             (string= new-content-hash old-content-hash))
-        (quelpa-file-version file-path type version old-time-stamp)
-      (unless (eq fetcher 'url)
-        (delete-directory dir t)
-        (make-directory dir)
-        (if (eq type 'file)
-            (copy-file file-path dir t t t t)
-          (copy-directory file-path dir t t t)))
-      (quelpa-build--dump new-stamp-info stamp-file)
-      (quelpa-file-version file-path type version time-stamp))))
-
-;; --- package-build fork ------------------------------------------
-
-(defcustom quelpa-build-verbose t
-  "When non-nil, then print additional progress information."
-  :type 'boolean)
-
-(defcustom quelpa-build-stable nil
-  "When non-nil, then try to build packages from versions-tagged code."
-  :type 'boolean)
-
-(defcustom quelpa-build-timeout-executable
-  (let ((prog (or (executable-find "timeout")
-                  (executable-find "gtimeout"))))
-    (when (and prog
-               (string-match-p "^ *-k"
-                               (shell-command-to-string (concat prog " --help"))))
-      prog))
-  "Path to a GNU coreutils \"timeout\" command if available.
-This must be a version which supports the \"-k\" option."
-  :type '(file :must-match t))
-
-(defcustom quelpa-build-timeout-secs 600
-  "Wait this many seconds for external processes to complete.
-
-If an external process takes longer than specified here to
-complete, then it is terminated.  This only has an effect
-if `quelpa-build-timeout-executable' is non-nil."
-  :type 'number)
-
-(defcustom quelpa-build-tar-executable
-  (or (executable-find "gtar")
-      (executable-find "tar"))
-  "Path to a (preferably GNU) tar command.
-Certain package names (e.g. \"@\") may not work properly with a BSD tar."
-  :type '(file :must-match t))
-
-(defcustom quelpa-build-version-regexp "^[rRvV]?\\(.*\\)$"
-  "Default pattern for matching valid version-strings within repository tags.
-The string in the capture group should be parsed as valid by `version-to-list'."
-  :type 'string)
-
-;;; Internal Variables
-
-(defconst quelpa-build-default-files-spec
-  '("*.el" "*.el.in" "dir"
-    "*.info" "*.texi" "*.texinfo"
-    "doc/dir" "doc/*.info" "doc/*.texi" "doc/*.texinfo"
-    (:exclude ".dir-locals.el" "test.el" "tests.el" "*-test.el" "*-tests.el"))
-  "Default value for :files attribute in recipes.")
-
-;;; Utilities
-
-(defun quelpa-build--message (format-string &rest args)
-  "Behave like `message' if `quelpa-build-verbose' is non-nil.
-Otherwise do nothing."
-  (when quelpa-build-verbose
-    (apply 'message format-string args)))
-
-(defun quelpa-build--slurp-file (file)
-  "Return the contents of FILE as a string, or nil if no such file exists."
-  (when (file-exists-p file)
-    (with-temp-buffer
-      (insert-file-contents file)
-      (buffer-substring-no-properties (point-min) (point-max)))))
-
-(defun quelpa-build--string-rtrim (str)
-  "Remove trailing whitespace from `STR'."
-  (replace-regexp-in-string "[ \t\n\r]+$" "" str))
-
-(defun quelpa-build--trim (str &optional chr)
-  "Return a copy of STR without any trailing CHR (or space if unspecified)."
-  (if (equal (elt str (1- (length str))) (or chr ? ))
-      (substring str 0 (1- (length str)))
-    str))
-
-;;; Version Handling
-
-(defun quelpa-build--valid-version (str &optional regexp)
-  "Apply to STR the REGEXP if defined, \
-then pass the string to `version-to-list' and return the result, \
-or nil if the version cannot be parsed."
-  (when (and regexp (string-match regexp str))
-    (setq str (match-string 1 str)))
-  (ignore-errors (version-to-list str)))
-
-(defun quelpa-build--parse-time (str)
-  "Parse STR as a time, and format as a YYYYMMDD.HHMM string."
-  ;; We remove zero-padding the HH portion, as it is lost
-  ;; when stored in the archive-contents
-  (setq str (substring-no-properties str))
-  (let ((time (date-to-time
-               (if (string-match "\
-^\\([0-9]\\{4\\}\\)/\\([0-9]\\{2\\}\\)/\\([0-9]\\{2\\}\\) \
-\\([0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\}\\)$" str)
-                   (concat (match-string 1 str) "-" (match-string 2 str) "-"
-                           (match-string 3 str) " " (match-string 4 str))
-                 str))))
-    (concat (format-time-string "%Y%m%d." time)
-            (format "%d" (string-to-number (format-time-string "%H%M" time))))))
-
-(defun quelpa-build--find-parse-time (regexp &optional bound)
-  "Find REGEXP in current buffer and format as a time-based version string.
-An optional second argument bounds the search; it is a buffer
-position.  The match found must not end after that position."
-  (and (re-search-backward regexp bound t)
-       (quelpa-build--parse-time (match-string-no-properties 1))))
-
-(defun quelpa-build--find-parse-time-newest (regexp &optional bound)
-  "Find REGEXP in current buffer and format as a time-based version string.
-An optional second argument bounds the search; it is a buffer
-position.  The match found must not end after that position."
-  (save-match-data
-    (let (cur matches)
-      (while (setq cur (quelpa-build--find-parse-time regexp bound))
-        (push cur matches))
-      (car (nreverse (sort matches 'string<))))))
-
-(defun quelpa-build--find-version-newest (regexp &optional bound)
-  "Find the newest version matching REGEXP before point.
-An optional second argument bounds the search; it is a buffer
-position.  The match found must not before after that position."
-  (let ((tags (split-string
-               (buffer-substring-no-properties
-                (or bound (point-min)) (point))
-               "\n")))
-    (setq tags (append
-                (mapcar
-                 ;; Because the default `version-separator' is ".",
-                 ;; version-strings like "1_4_5" will be parsed
-                 ;; wrongly as (1 -4 4 -4 5), so we set
-                 ;; `version-separator' to "_" below and run again.
-                 (lambda (tag)
-                   (when (quelpa-build--valid-version tag regexp)
-                     (list (quelpa-build--valid-version tag regexp) tag)))
-                 tags)
-                (mapcar
-                 ;; Check for valid versions again, this time using
-                 ;; "_" as a separator instead of "." to catch
-                 ;; version-strings like "1_4_5".  Since "_" is
-                 ;; otherwise treated as a snapshot separator by
-                 ;; `version-regexp-alist', we don't have to worry
-                 ;; about the incorrect version list above—(1 -4 4 -4
-                 ;; 5)—since it will always be treated as older by
-                 ;; `version-list-<'.
-                 (lambda (tag)
-                   (let ((version-separator "_"))
-                     (when (quelpa-build--valid-version tag regexp)
-                       (list (quelpa-build--valid-version tag regexp) tag))))
-                 tags)))
-    (setq tags (cl-remove-if nil tags))
-    ;; Returns a list like ((0 1) ("v0.1")); the first element is used
-    ;; for comparison and for `package-version-join', and the second
-    ;; (the original tag) is used by git/hg/etc.
-    (car (nreverse (sort tags (lambda (v1 v2) (version-list-< (car v1) (car v2))))))))
-
-;;; Run Process
-
-(defun quelpa-build--run-process (dir command &rest args)
-  "In DIR (or `default-directory' if unset) run COMMAND with ARGS.
-Output is written to the current buffer."
-  (let ((default-directory (file-name-as-directory (or dir default-directory)))
-        (argv (nconc (unless (eq system-type 'windows-nt)
-                       (list "env" "LC_ALL=C"))
-                     (if quelpa-build-timeout-executable
-                         (nconc (list quelpa-build-timeout-executable
-                                      "-k" "60" (number-to-string
-                                                 quelpa-build-timeout-secs)
-                                      command)
-                                args)
-                       (cons command args)))))
-    (unless (file-directory-p default-directory)
-      (error "Can't run process in non-existent directory: %s" default-directory))
-    (let ((exit-code (apply 'process-file
-                            (car argv) nil (current-buffer) t
-                            (cdr argv))))
-      (or (zerop exit-code)
-          (error "Command '%s' exited with non-zero status %d: %s"
-                 argv exit-code (buffer-string))))))
-
-(defun quelpa-build--run-process-match (regexp dir prog &rest args)
-  "Run PROG with args and return the first match for REGEXP in its output.
-PROG is run in DIR, or if that is nil in `default-directory'."
-  (with-temp-buffer
-    (apply 'quelpa-build--run-process dir prog args)
-    (goto-char (point-min))
-    (re-search-forward regexp)
-    (match-string-no-properties 1)))
-
-;;; Checkout
-;;;; Common
-
-(defun quelpa-build-checkout (package-name config working-dir)
-  "Check out source for PACKAGE-NAME with CONFIG under WORKING-DIR.
-In turn, this function uses the :fetcher option in the CONFIG to
-choose a source-specific fetcher function, which it calls with
-the same arguments.
-
-Returns the package version as a string."
-  (let ((fetcher (plist-get config :fetcher)))
-    (quelpa-build--message "Fetcher: %s" fetcher)
-    (unless (eq fetcher 'wiki)
-      (quelpa-build--message "Source: %s\n"
-                             (or (plist-get config :repo)
-                                 (plist-get config :url))))
-    (funcall (intern (format "quelpa-build--checkout-%s" fetcher))
-             package-name config (file-name-as-directory working-dir))))
-
-(defun quelpa-build--princ-exists (dir)
-  "Print a message that the contents of DIR will be updated."
-  (quelpa-build--message "Updating %s" dir))
-
-(defun quelpa-build--princ-checkout (repo dir)
-  "Print a message that REPO will be checked out into DIR."
-  (quelpa-build--message "Cloning %s to %s" repo dir))
-
-;;;; Wiki
-
-(defvar quelpa-build--last-wiki-fetch-time 0
-  "The time at which an emacswiki URL was last requested.
-This is used to avoid exceeding the rate limit of 1 request per 2
-seconds; the server cuts off after 10 requests in 20 seconds.")
-
-(defvar quelpa-build--wiki-min-request-interval 3
-  "The shortest permissible interval between successive requests for Emacswiki URLs.")
-
-(defmacro quelpa-build--with-wiki-rate-limit (&rest body)
-  "Rate-limit BODY code passed to this macro to match EmacsWiki's rate limiting."
-  (let ((elapsed (cl-gensym)))
-    `(let ((,elapsed (- (float-time) quelpa-build--last-wiki-fetch-time)))
-       (when (< ,elapsed quelpa-build--wiki-min-request-interval)
-         (let ((wait (- quelpa-build--wiki-min-request-interval ,elapsed)))
-           (quelpa-build--message
-            "Waiting %.2f secs before hitting Emacswiki again" wait)
-           (sleep-for wait)))
-       (unwind-protect
-           (progn ,@body)
-         (setq quelpa-build--last-wiki-fetch-time (float-time))))))
-
-(require 'mm-decode)
-(defvar url-http-response-status)
-(defvar url-http-end-of-headers)
-
-(defun quelpa-build--url-copy-file (url newname &optional ok-if-already-exists)
-  "Copy URL to NEWNAME.  Both args must be strings.
-Returns the http request's header as a string.
-Like `url-copy-file', but it produces an error if the http response is not 200.
-Signals a `file-already-exists' error if file NEWNAME already exists,
-unless a third argument OK-IF-ALREADY-EXISTS is supplied and non-nil.
-A number as third arg means request confirmation if NEWNAME already exists."
-  (if (and (file-exists-p newname)
-           (not ok-if-already-exists))
-      (error "Opening output file: File already exists, %s" newname))
-  (let ((buffer (url-retrieve-synchronously url))
-        (headers nil)
-        (handle nil))
-    (if (not buffer)
-        (error "Opening input file: No such file or directory, %s" url))
-    (with-current-buffer buffer
-      (unless (= 200 url-http-response-status)
-        (error "HTTP error %s fetching %s" url-http-response-status url))
-      (setq handle (mm-dissect-buffer t))
-      (mail-narrow-to-head)
-      (setq headers (buffer-string)))
-    (mm-save-part-to-file handle newname)
-    (kill-buffer buffer)
-    (mm-destroy-parts handle)
-    headers))
-
-(defun quelpa-build--grab-wiki-file (filename)
-  "Download FILENAME from emacswiki, returning its last-modified time."
-  (let ((download-url
-         (format "https://www.emacswiki.org/emacs/download/%s" filename))
-        headers)
-    (quelpa-build--with-wiki-rate-limit
-     (setq headers (quelpa-build--url-copy-file download-url filename t)))
-    (when (zerop (nth 7 (file-attributes filename)))
-      (error "Wiki file %s was empty - has it been removed?" filename))
-    (quelpa-build--parse-time
-     (with-temp-buffer
-       (insert headers)
-       (mail-fetch-field "last-modified")))))
-
-(defun quelpa-build--checkout-wiki (name config dir)
-  "Checkout package NAME with config CONFIG from the EmacsWiki into DIR."
-  (unless quelpa-build-stable
-    (with-current-buffer (get-buffer-create "*quelpa-build-checkout*")
-      (unless (file-exists-p dir)
-        (make-directory dir))
-      (let ((files (or (plist-get config :files)
-                       (list (format "%s.el" name))))
-            (default-directory dir))
-        (car (nreverse (sort (mapcar 'quelpa-build--grab-wiki-file files)
-                             'string-lessp)))))))
-
-;;;; Darcs
-
-(defun quelpa-build--darcs-repo (dir)
-  "Get the current darcs repo for DIR."
-  (quelpa-build--run-process-match "Default Remote: \\(.*\\)"
-                                   dir "darcs" "show" "repo"))
-
-(defun quelpa-build--checkout-darcs (name config dir)
-  "Check package NAME with config CONFIG out of darcs into DIR."
-  (let ((repo (plist-get config :url)))
-    (with-current-buffer (get-buffer-create "*quelpa-build-checkout*")
-      (cond
-       ((and (file-exists-p (expand-file-name "_darcs" dir))
-             (string-equal (quelpa-build--darcs-repo dir) repo))
-        (quelpa-build--princ-exists dir)
-        (quelpa-build--run-process dir "darcs" "pull" "--all"))
-       (t
-        (when (file-exists-p dir)
-          (delete-directory dir t))
-        (quelpa-build--princ-checkout repo dir)
-        (quelpa-build--run-process nil "darcs" "get" repo dir)))
-      (if quelpa-build-stable
-          (let* ((min-bound (goto-char (point-max)))
-                 (tag-version
-                  (and (quelpa-build--run-process dir "darcs" "show" "tags")
-                       (or (quelpa-build--find-version-newest
-                            (or (plist-get config :version-regexp)
-                                quelpa-build-version-regexp)
-                            min-bound)
-                           (error "No valid stable versions found for %s" name)))))
-            (quelpa-build--run-process dir "darcs" "obliterate"
-                                       "--all" "--from-tag"
-                                       (cadr tag-version))
-            ;; Return the parsed version as a string
-            (package-version-join (car tag-version)))
-        (apply 'quelpa-build--run-process
-               dir "darcs" "changes" "--max-count" "1"
-               (quelpa-build--expand-source-file-list dir config))
-        (quelpa-build--find-parse-time "\
-\\([a-zA-Z]\\{3\\} [a-zA-Z]\\{3\\} \
-\\( \\|[0-9]\\)[0-9] [0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\} \
-[A-Za-z]\\{3\\} [0-9]\\{4\\}\\)")))))
-
-;;;; Fossil
-
-(defun quelpa-build--fossil-repo (dir)
-  "Get the current fossil repo for DIR."
-  (quelpa-build--run-process-match "\\(.*\\)" dir "fossil" "remote-url"))
-
-(defun quelpa-build--checkout-fossil (name config dir)
-  "Check package NAME with config CONFIG out of fossil into DIR."
-  (unless quelpa-build-stable
-    (let ((repo (plist-get config :url)))
-      (with-current-buffer (get-buffer-create "*quelpa-build-checkout*")
-        (cond
-         ((and (or (file-exists-p (expand-file-name ".fslckout" dir))
-                   (file-exists-p (expand-file-name "_FOSSIL_" dir)))
-               (string-equal (quelpa-build--fossil-repo dir) repo))
-          (quelpa-build--princ-exists dir)
-          (quelpa-build--run-process dir "fossil" "update"))
-         (t
-          (when (file-exists-p dir)
-            (delete-directory dir t))
-          (quelpa-build--princ-checkout repo dir)
-          (make-directory dir)
-          (quelpa-build--run-process dir "fossil" "clone" repo "repo.fossil")
-          (quelpa-build--run-process dir "fossil" "open" "repo.fossil")))
-        (quelpa-build--run-process dir "fossil" "timeline" "-n" "1" "-t" "ci")
-        (or (quelpa-build--find-parse-time "\
-=== \\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} ===\n\
-[0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\}\\) ")
-            (error "No valid timestamps found!"))))))
-
-;;;; Svn
-
-(defun quelpa-build--svn-repo (dir)
-  "Get the current svn repo for DIR."
-  (quelpa-build--run-process-match "URL: \\(.*\\)" dir "svn" "info"))
-
-(defun quelpa-build--checkout-svn (name config dir)
-  "Check package NAME with config CONFIG out of svn into DIR."
-  (unless quelpa-build-stable
-    (with-current-buffer (get-buffer-create "*quelpa-build-checkout*")
-      (let ((repo (quelpa-build--trim (plist-get config :url) ?/))
-            (bound (goto-char (point-max))))
-        (cond
-         ((and (file-exists-p (expand-file-name ".svn" dir))
-               (string-equal (quelpa-build--svn-repo dir) repo))
-          (quelpa-build--princ-exists dir)
-          (quelpa-build--run-process dir "svn" "up"))
-         (t
-          (when (file-exists-p dir)
-            (delete-directory dir t))
-          (quelpa-build--princ-checkout repo dir)
-          (quelpa-build--run-process nil "svn" "checkout" repo dir)))
-        (apply 'quelpa-build--run-process dir "svn" "info"
-               (quelpa-build--expand-source-file-list dir config))
-        (or (quelpa-build--find-parse-time-newest "\
-Last Changed Date: \\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} \
-[0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\}\\( [+-][0-9]\\{4\\}\\)?\\)"
-                                                  bound)
-            (error "No valid timestamps found!"))))))
-
-;;;; Cvs
-
-(defun quelpa-build--cvs-repo (dir)
-  "Get the current CVS root and repository for DIR.
-
-Return a cons cell whose `car' is the root and whose `cdr' is the repository."
-  (apply 'cons
-         (mapcar (lambda (file)
-                   (quelpa-build--string-rtrim
-                    (quelpa-build--slurp-file (expand-file-name file dir))))
-                 '("CVS/Root" "CVS/Repository"))))
-
-(defun quelpa-build--checkout-cvs (name config dir)
-  "Check package NAME with config CONFIG out of cvs into DIR."
-  (unless quelpa-build-stable
-    (with-current-buffer (get-buffer-create "*quelpa-build-checkout*")
-      (let ((root (quelpa-build--trim (plist-get config :url) ?/))
-            (repo (or (plist-get config :module) (symbol-name name)))
-            (bound (goto-char (point-max)))
-            latest)
-        (cond
-         ((and (file-exists-p (expand-file-name "CVS" dir))
-               (equal (quelpa-build--cvs-repo dir) (cons root repo)))
-          (quelpa-build--princ-exists dir)
-          (quelpa-build--run-process dir "cvs" "update" "-dP"))
-         (t
-          (when (file-exists-p dir)
-            (delete-directory dir t))
-          (quelpa-build--princ-checkout (format "%s from %s" repo root) dir)
-          ;; CVS insists on relative paths as target directory for checkout (for
-          ;; whatever reason), and puts "CVS" directories into every subdirectory
-          ;; of the current working directory given in the target path. To get CVS
-          ;; to just write to DIR, we need to execute CVS from the parent
-          ;; directory of DIR, and specific DIR as relative path.  Hence all the
-          ;; following mucking around with paths.  CVS is really horrid.
-          (let ((dir (directory-file-name dir)))
-            (quelpa-build--run-process (file-name-directory dir)
-                                       "env" "TZ=UTC" "cvs" "-z3"
-                                       "-d" root "checkout"
-                                       "-d" (file-name-nondirectory dir)
-                                       repo))))
-        (apply 'quelpa-build--run-process dir "cvs" "log"
-               (quelpa-build--expand-source-file-list dir config))
-
-        ;; `cvs log` does not provide a way to view the previous N
-        ;; revisions, so instead of parsing the entire log we examine
-        ;; the Entries file, which looks like this:
-        ;;
-        ;; /.cvsignore/1.2/Thu Sep  1 12:42:02 2005//
-        ;; /CHANGES/1.1/Tue Oct  4 11:47:54 2005//
-        ;; /GNUmakefile/1.8/Tue Oct  4 11:47:54 2005//
-        ;; /Makefile/1.14/Tue Oct  4 11:47:54 2005//
-        ;;
-        (insert-file-contents (concat dir "/CVS/Entries"))
-        (setq latest
-              (car
-               (sort
-                (split-string (buffer-substring-no-properties (point) (point-max)) "\n")
-                (lambda (x y)
-                  (when (string-match "^\\/[^\\/]*\\/[^\\/]*\\/\\([^\\/]*\\)\\/\\/$" x)
-                    (setq x (quelpa-build--parse-time (match-string 1 x))))
-                  (when (string-match "^\\/[^\\/]*\\/[^\\/]*\\/\\([^\\/]*\\)\\/\\/$" y)
-                    (setq y (quelpa-build--parse-time (match-string 1 y))))
-                  (version-list-<= (quelpa-build--valid-version y)
-                                   (quelpa-build--valid-version x))))))
-        (when (string-match "^\\/[^\\/]*\\/[^\\/]*\\/\\([^\\/]*\\)\\/\\/$" latest)
-          (setq latest (match-string 1 latest)))
-        (or (quelpa-build--parse-time latest)
-            (error "No valid timestamps found!"))))))
-
-;;;; Git
-
-(defun quelpa-build--git-repo (dir)
-  "Get the current git repo for DIR."
-  (quelpa-build--run-process-match
-   "Fetch URL: \\(.*\\)" dir "git" "remote" "show" "-n" "origin"))
-
-(defun quelpa-build--checkout-git (name config dir)
-  "Check package NAME with config CONFIG out of git into DIR."
-  (let ((repo (plist-get config :url))
-        (commit (or (plist-get config :commit)
-                    (let ((branch (plist-get config :branch)))
-                      (when branch
-                        (concat "origin/" branch))))))
-    (with-current-buffer (get-buffer-create "*quelpa-build-checkout*")
-      (goto-char (point-max))
-      (cond
-       ((and (file-exists-p (expand-file-name ".git" dir))
-             (string-equal (quelpa-build--git-repo dir) repo))
-        (quelpa-build--princ-exists dir)
-        (quelpa-build--run-process dir "git" "fetch" "--all" "--tags"))
-       (t
-        (when (file-exists-p dir)
-          (delete-directory dir t))
-        (quelpa-build--princ-checkout repo dir)
-        (quelpa-build--run-process nil "git" "clone" repo dir)))
-      (if quelpa-build-stable
-          (let* ((min-bound (goto-char (point-max)))
-                 (tag-version
-                  (and (quelpa-build--run-process dir "git" "tag")
-                       (or (quelpa-build--find-version-newest
-                            (or (plist-get config :version-regexp)
-                                quelpa-build-version-regexp)
-                            min-bound)
-                           (error "No valid stable versions found for %s" name)))))
-            ;; Using reset --hard here to comply with what's used for
-            ;; unstable, but maybe this should be a checkout?
-            (quelpa-build--update-git-to-ref
-             dir (concat "tags/" (cadr tag-version)))
-            ;; Return the parsed version as a string
-            (package-version-join (car tag-version)))
-        (quelpa-build--update-git-to-ref
-         dir (or commit (concat "origin/" (quelpa-build--git-head-branch dir))))
-        (apply 'quelpa-build--run-process
-               dir "git" "log" "--first-parent" "-n1" "--pretty=format:'\%ci'"
-               (quelpa-build--expand-source-file-list dir config))
-        (quelpa-build--find-parse-time "\
-\\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} \
-[0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\}\\( [+-][0-9]\\{4\\}\\)?\\)")))))
-
-(defun quelpa-build--git-head-branch (dir)
-  "Get the current git repo for DIR."
-  (or (ignore-errors
-        (quelpa-build--run-process-match
-         "HEAD branch: \\(.*\\)" dir "git" "remote" "show" "origin"))
-      "master"))
-
-(defun quelpa-build--git-head-sha (dir)
-  "Get the current head SHA for DIR."
-  (ignore-errors
-    (quelpa-build--run-process-match
-     "\\(.*\\)" dir "git" "rev-parse" "HEAD")))
-
-(defun quelpa-build--update-git-to-ref (dir ref)
-  "Update the git repo in DIR so that HEAD is REF."
-  (quelpa-build--run-process dir "git" "reset" "--hard" ref)
-  (quelpa-build--run-process dir "git" "submodule" "sync" "--recursive")
-  (quelpa-build--run-process dir "git" "submodule" "update" "--init" "--recursive"))
-
-(defun quelpa-build--checkout-github (name config dir)
-  "Check package NAME with config CONFIG out of github into DIR."
-  (let ((url (format "https://github.com/%s.git" (plist-get config :repo))))
-    (quelpa-build--checkout-git name (plist-put (copy-sequence config) :url url) dir)))
-
-(defun quelpa-build--checkout-gitlab (name config dir)
-  "Check package NAME with config CONFIG out of gitlab into DIR."
-  (let ((url (format "https://gitlab.com/%s.git" (plist-get config :repo))))
-    (quelpa-build--checkout-git name (plist-put (copy-sequence config) :url url) dir)))
-
-;;;; Bzr
-
-(defun quelpa-build--bzr-repo (dir)
-  "Get the current bzr repo for DIR."
-  (quelpa-build--run-process-match "parent branch: \\(.*\\)" dir "bzr" "info"))
-
-(defun quelpa-build--checkout-bzr (name config dir)
-  "Check package NAME with config CONFIG out of bzr into DIR."
-  (let ((repo (quelpa-build--run-process-match
-               "\\(?:branch root\\|repository branch\\): \\(.*\\)"
-               nil "bzr" "info" (plist-get config :url))))
-    (with-current-buffer (get-buffer-create "*quelpa-build-checkout*")
-      (goto-char (point-max))
-      (cond
-       ((and (file-exists-p (expand-file-name ".bzr" dir))
-             (string-equal (quelpa-build--bzr-repo dir) repo))
-        (quelpa-build--princ-exists dir)
-        (quelpa-build--run-process dir "bzr" "merge" "--force"))
-       (t
-        (when (file-exists-p dir)
-          (delete-directory dir t))
-        (quelpa-build--princ-checkout repo dir)
-        (quelpa-build--run-process nil "bzr" "branch" repo dir)))
-      (if quelpa-build-stable
-          (let ((bound (goto-char (point-max)))
-                (regexp (or (plist-get config :version-regexp)
-                            quelpa-build-version-regexp))
-                tag-version)
-            (quelpa-build--run-process dir "bzr" "tags")
-            (goto-char bound)
-            (ignore-errors (while (re-search-forward "\\ +.*")
-                             (replace-match "")))
-            (setq tag-version
-                  (or (quelpa-build--find-version-newest regexp bound)
-                      (error "No valid stable versions found for %s" name)))
-            (quelpa-build--run-process dir
-                                       "bzr" "revert" "-r"
-                                       (concat "tag:" (cadr tag-version)))
-            ;; Return the parsed version as a string
-            (package-version-join (car tag-version)))
-        (apply 'quelpa-build--run-process dir "bzr" "log" "-l1"
-               (quelpa-build--expand-source-file-list dir config))
-        (quelpa-build--find-parse-time "\
-\\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} \
-[0-9]\\{2\\}:[0-9]\\{2\\}:[0-9]\\{2\\}\\( [+-][0-9]\\{4\\}\\)?\\)")))))
-
-;;;; Hg
-
-(defun quelpa-build--hg-repo (dir)
-  "Get the current hg repo for DIR."
-  (quelpa-build--run-process-match "default = \\(.*\\)" dir "hg" "paths"))
-
-(defun quelpa-build--checkout-hg (name config dir)
-  "Check package NAME with config CONFIG out of hg into DIR."
-  (let ((repo (plist-get config :url)))
-    (with-current-buffer (get-buffer-create "*quelpa-build-checkout*")
-      (goto-char (point-max))
-      (cond
-       ((and (file-exists-p (expand-file-name ".hg" dir))
-             (string-equal (quelpa-build--hg-repo dir) repo))
-        (quelpa-build--princ-exists dir)
-        (quelpa-build--run-process dir "hg" "pull")
-        (quelpa-build--run-process dir "hg" "update"))
-       (t
-        (when (file-exists-p dir)
-          (delete-directory dir t))
-        (quelpa-build--princ-checkout repo dir)
-        (quelpa-build--run-process nil "hg" "clone" repo dir)))
-      (if quelpa-build-stable
-          (let ((min-bound (goto-char (point-max)))
-                (regexp (or (plist-get config :version-regexp)
-                            quelpa-build-version-regexp))
-                tag-version)
-            (quelpa-build--run-process dir "hg" "tags")
-            ;; The output of `hg tags` shows the ref of the tag as well
-            ;; as the tag itself, e.g.:
-            ;;
-            ;; tip                             1696:73ad80e8fea1
-            ;; 1.2.8                           1691:464af57fd2b7
-            ;;
-            ;; So here we remove that second column before passing the
-            ;; buffer contents to `quelpa-build--find-version-newest'.
-            ;; This isn't strictly necessary for Mercurial since the
-            ;; colon in "1691:464af57fd2b7" means that won't be parsed
-            ;; as a valid version-string, but it's an example of how to
-            ;; do it in case it's necessary elsewhere.
-            (goto-char min-bound)
-            (ignore-errors (while (re-search-forward "\\ +.*")
-                             (replace-match "")))
-            (setq tag-version
-                  (or (quelpa-build--find-version-newest regexp min-bound)
-                      (error "No valid stable versions found for %s" name)))
-            (quelpa-build--run-process dir "hg" "update" (cadr tag-version))
-            ;; Return the parsed version as a string
-            (package-version-join (car tag-version)))
-        (apply 'quelpa-build--run-process
-               dir "hg" "log" "--style" "compact" "-l1"
-               (quelpa-build--expand-source-file-list dir config))
-        (quelpa-build--find-parse-time "\
-\\([0-9]\\{4\\}-[0-9]\\{2\\}-[0-9]\\{2\\} \
-[0-9]\\{2\\}:[0-9]\\{2\\}\\( [+-][0-9]\\{4\\}\\)?\\)")))))
-
-(defun quelpa-build--checkout-bitbucket (name config dir)
-  "Check package NAME with config CONFIG out of bitbucket into DIR."
-  (let ((url (format "https://bitbucket.com/%s" (plist-get config :repo))))
-    (quelpa-build--checkout-hg name (plist-put (copy-sequence config) :url url) dir)))
-
-;;; Utilities
-
-(defun quelpa-build--dump (data file &optional pretty-print)
-  "Write DATA to FILE as a Lisp sexp.
-Optionally PRETTY-PRINT the data."
-  (with-temp-file file
-    (quelpa-build--message "File: %s" file)
-    (if pretty-print
-        (pp data (current-buffer))
-      (print data (current-buffer)))))
-
-(defun quelpa-build--write-pkg-file (pkg-file pkg-info)
-  "Write PKG-FILE containing PKG-INFO."
-  (with-temp-file pkg-file
-    (pp
-     `(define-package
-        ,(aref pkg-info 0)
-        ,(aref pkg-info 3)
-        ,(aref pkg-info 2)
-        ',(mapcar
-           (lambda (elt)
-             (list (car elt)
-                   (package-version-join (cadr elt))))
-           (aref pkg-info 1))
-        ;; Append our extra information
-        ,@(cl-mapcan (lambda (entry)
-                       (let ((value (cdr entry)))
-                         (when (or (symbolp value) (listp value))
-                           ;; We must quote lists and symbols,
-                           ;; because Emacs 24.3 and earlier evaluate
-                           ;; the package information, which would
-                           ;; break for unquoted symbols or lists
-                           (setq value (list 'quote value)))
-                         (list (car entry) value)))
-                     (when (> (length pkg-info) 4)
-                       (aref pkg-info 4))))
-     (current-buffer))
-    (princ ";; Local Variables:\n;; no-byte-compile: t\n;; End:\n"
-           (current-buffer))))
-
-(defun quelpa-build--read-from-file (file)
-  "Read and return the Lisp data stored in FILE, or nil if no such file exists."
-  (when (file-exists-p file)
-    (car (read-from-string (quelpa-build--slurp-file file)))))
-
-(defun quelpa-build--create-tar (file dir &optional files)
-  "Create a tar FILE containing the contents of DIR, or just FILES if non-nil."
-  (when (eq system-type 'windows-nt)
-    (setq file (replace-regexp-in-string "^\\([a-z]\\):" "/\\1" file)))
-  (apply 'process-file
-         quelpa-build-tar-executable nil
-         (get-buffer-create "*quelpa-build-checkout*")
-         nil "-cvf"
-         file
-         "--exclude=.svn"
-         "--exclude=CVS"
-         "--exclude=.git"
-         "--exclude=_darcs"
-         "--exclude=.fslckout"
-         "--exclude=_FOSSIL_"
-         "--exclude=.bzr"
-         "--exclude=.hg"
-         (or (mapcar (lambda (fn) (concat dir "/" fn)) files) (list dir))))
-
-(defun quelpa-build--find-package-commentary (file-path)
-  "Get commentary section from FILE-PATH."
-  (when (file-exists-p file-path)
-    (with-temp-buffer
-      (insert-file-contents file-path)
-      (lm-commentary))))
-
-(defun quelpa-build--write-pkg-readme (target-dir commentary file-name)
-  "In TARGET-DIR, write COMMENTARY to a -readme.txt file prefixed with FILE-NAME."
-  (when commentary
-    (with-temp-buffer
-      (insert commentary)
-      ;; Adapted from `describe-package-1'.
-      (goto-char (point-min))
-      (save-excursion
-        (when (re-search-forward "^;;; Commentary:\n" nil t)
-          (replace-match ""))
-        (while (re-search-forward "^\\(;+ ?\\)" nil t)
-          (replace-match ""))
-        (goto-char (point-min))
-        (when (re-search-forward "\\`\\( *\n\\)+" nil t)
-          (replace-match "")))
-      (delete-trailing-whitespace)
-      (let ((coding-system-for-write buffer-file-coding-system))
-        (write-region nil nil
-                      (quelpa-build--readme-file-name target-dir file-name))))))
-
-(defun quelpa-build--readme-file-name (target-dir file-name)
-  "Name of the readme file in TARGET-DIR for the package FILE-NAME."
-  (expand-file-name (concat file-name "-readme.txt")
-                    target-dir))
-
-(defun quelpa-build--update-or-insert-version (version)
-  "Ensure current buffer has a \"Package-Version: VERSION\" header."
-  (goto-char (point-min))
-  (if (let ((case-fold-search t))
-        (re-search-forward "^;+* *Package-Version *: *" nil t))
-      (progn
-        (move-beginning-of-line nil)
-        (search-forward "V" nil t)
-        (backward-char)
-        (insert "X-Original-")
-        (move-beginning-of-line nil))
-    ;; Put the new header in a sensible place if we can
-    (re-search-forward "^;+* *\\(Version\\|Package-Requires\\|Keywords\\|URL\\) *:"
-                       nil t)
-    (forward-line))
-  (insert (format ";; Package-Version: %s" version))
-  (newline))
-
-(defun quelpa-build--ensure-ends-here-line (file-path)
-  "Add a 'FILE-PATH ends here' trailing line if missing."
-  (save-excursion
-    (goto-char (point-min))
-    (let ((trailer (concat ";;; "
-                           (file-name-nondirectory file-path)
-                           " ends here")))
-      (unless (search-forward trailer nil t)
-        (goto-char (point-max))
-        (newline)
-        (insert trailer)
-        (newline)))))
-
-(defun quelpa-build--get-package-info (file-path)
-  "Get a vector of package info from the docstrings in FILE-PATH."
-  (when (file-exists-p file-path)
-    (ignore-errors
-      (with-temp-buffer
-        (insert-file-contents file-path)
-        ;; next few lines are a hack for some packages that aren't
-        ;; commented properly.
-        (quelpa-build--update-or-insert-version "0")
-        (quelpa-build--ensure-ends-here-line file-path)
-        (cl-flet ((package-strip-rcs-id (str) "0"))
-          (quelpa-build--package-buffer-info-vec))))))
-
-(defun quelpa-build--get-pkg-file-info (file-path)
-  "Get a vector of package info from \"-pkg.el\" file FILE-PATH."
-  (when (file-exists-p file-path)
-    (let ((package-def (quelpa-build--read-from-file file-path)))
-      (if (eq 'define-package (car package-def))
-          (let* ((pkgfile-info (cdr package-def))
-                 (descr (nth 2 pkgfile-info))
-                 (rest-plist (cl-subseq pkgfile-info (min 4 (length pkgfile-info))))
-                 (extras (let (alist)
-                           (while rest-plist
-                             (unless (memq (car rest-plist) '(:kind :archive))
-                               (let ((value (cadr rest-plist)))
-                                 (when value
-                                   (push (cons (car rest-plist)
-                                               (if (eq (car-safe value) 'quote)
-                                                   (cadr value)
-                                                 value))
-                                         alist))))
-                             (setq rest-plist (cddr rest-plist)))
-                           alist)))
-            (when (string-match "[\r\n]" descr)
-              (error "Illegal multi-line package description in %s" file-path))
-            (vector
-             (nth 0 pkgfile-info)
-             (mapcar
-              (lambda (elt)
-                (unless (symbolp (car elt))
-                  (error "Invalid package name in dependency: %S" (car elt)))
-                (list (car elt) (version-to-list (cadr elt))))
-              (eval (nth 3 pkgfile-info)))
-             descr
-             (nth 1 pkgfile-info)
-             extras))
-        (error "No define-package found in %s" file-path)))))
-
-(defun quelpa-build--merge-package-info (pkg-info name version)
-  "Return a version of PKG-INFO updated with NAME, VERSION and info from CONFIG.
-If PKG-INFO is nil, an empty one is created."
-  (let ((merged (or (copy-sequence pkg-info)
-                    (vector name nil "No description available." version))))
-    (aset merged 0 name)
-    (aset merged 3 version)
-    merged))
-
-(defun quelpa-build--archive-entry (pkg-info type)
-  "Return the archive-contents cons cell for PKG-INFO and TYPE."
-  (let ((name (intern (aref pkg-info 0)))
-        (requires (aref pkg-info 1))
-        (desc (or (aref pkg-info 2) "No description available."))
-        (version (aref pkg-info 3))
-        (extras (and (> (length pkg-info) 4)
-                     (aref pkg-info 4))))
-    (cons name
-          (vector (version-to-list version)
-                  requires
-                  desc
-                  type
-                  extras))))
-
-;;; Recipes
-
-(defun quelpa-build-expand-file-specs (dir specs &optional subdir allow-empty)
-  "In DIR, expand SPECS, optionally under SUBDIR.
-The result is a list of (SOURCE . DEST), where SOURCE is a source
-file path and DEST is the relative path to which it should be copied.
-
-If the resulting list is empty, an error will be reported.  Pass t
-for ALLOW-EMPTY to prevent this error."
-  (let ((default-directory dir)
-        (prefix (if subdir (format "%s/" subdir) ""))
-        (lst))
-    (dolist (entry specs lst)
-      (setq lst
-            (if (consp entry)
-                (if (eq :exclude (car entry))
-                    (cl-nset-difference lst
-                                        (quelpa-build-expand-file-specs
-                                         dir (cdr entry) nil t)
-                                        :key 'car
-                                        :test 'equal)
-                  (nconc lst
-                         (quelpa-build-expand-file-specs
-                          dir
-                          (cdr entry)
-                          (concat prefix (car entry))
-                          t)))
-              (nconc
-               lst (mapcar (lambda (f)
-                             (let ((destname)))
-                             (cons f
-                                   (concat prefix
-                                           (replace-regexp-in-string
-                                            "\\.in\\'"
-                                            ""
-                                            (file-name-nondirectory f)))))
-                           (file-expand-wildcards entry))))))
-    (when (and (null lst) (not allow-empty))
-      (error "No matching file(s) found in %s: %s" dir specs))
-    lst))
-
-(defun quelpa-build--config-file-list (config)
-  "Get the :files spec from CONFIG, or return `quelpa-build-default-files-spec'."
-  (let ((file-list (plist-get config :files)))
-    (cond
-     ((null file-list)
-      quelpa-build-default-files-spec)
-     ((eq :defaults (car file-list))
-      (append quelpa-build-default-files-spec (cdr file-list)))
-     (t
-      file-list))))
-
-(defun quelpa-build--expand-source-file-list (dir config)
-  "Shorthand way to expand paths in DIR for source files listed in CONFIG."
-  (mapcar 'car
-          (quelpa-build-expand-file-specs
-           dir (quelpa-build--config-file-list config))))
-
-(defun quelpa-build--generate-info-files (files source-dir target-dir)
-  "Create .info files from any .texi files listed in FILES.
-
-The source and destination file paths are expanded in SOURCE-DIR
-and TARGET-DIR respectively.
-
-Any of the original .texi(nfo) files found in TARGET-DIR are
-deleted."
-  (dolist (spec files)
-    (let* ((source-file (car spec))
-           (source-path (expand-file-name source-file source-dir))
-           (dest-file (cdr spec))
-           (info-path (expand-file-name
-                       (concat (file-name-sans-extension dest-file) ".info")
-                       target-dir)))
-      (when (string-match ".texi\\(nfo\\)?$" source-file)
-        (when (not (file-exists-p info-path))
-          (with-current-buffer (get-buffer-create "*quelpa-build-info*")
-            (ignore-errors
-              (quelpa-build--run-process
-               (file-name-directory source-path)
-               "makeinfo"
-               source-path
-               "-o"
-               info-path)
-              (quelpa-build--message "Created %s" info-path))))
-        (quelpa-build--message "Removing %s"
-                               (expand-file-name dest-file target-dir))
-        (delete-file (expand-file-name dest-file target-dir))))))
-
-;;; Info Manuals
-
-(defun quelpa-build--generate-dir-file (files target-dir)
-  "Create dir file from any .info files listed in FILES in TARGET-DIR."
-  (dolist (spec files)
-    (let* ((source-file (car spec))
-           (dest-file (cdr spec))
-           (info-path (expand-file-name
-                       (concat (file-name-sans-extension dest-file) ".info")
-                       target-dir)))
-      (when (and (or (string-match ".info$" source-file)
-                     (string-match ".texi\\(nfo\\)?$" source-file))
-                 (file-exists-p info-path))
-        (with-current-buffer (get-buffer-create "*quelpa-build-info*")
-          (ignore-errors
-            (quelpa-build--run-process
-             nil
-             "install-info"
-             (concat "--dir=" (expand-file-name "dir" target-dir))
-             info-path)))))))
-
-;;; Utilities
-
-(defun quelpa-build--copy-package-files (files source-dir target-dir)
-  "Copy FILES from SOURCE-DIR to TARGET-DIR.
-FILES is a list of (SOURCE . DEST) relative filepath pairs."
-  (cl-loop for (source-file . dest-file) in files
-           do (quelpa-build--copy-file
-               (expand-file-name source-file source-dir)
-               (expand-file-name dest-file target-dir))))
-
-(defun quelpa-build--copy-file (file newname)
-  "Copy FILE to NEWNAME and create parent directories for NEWNAME if they don't exist."
-  (let ((newdir (file-name-directory newname)))
-    (unless (file-exists-p newdir)
-      (make-directory newdir t)))
-  (cond
-   ((file-regular-p file)
-    (quelpa-build--message "%s -> %s" file newname)
-    (copy-file file newname))
-   ((file-directory-p file)
-    (quelpa-build--message "%s => %s" file newname)
-    (copy-directory file newname))))
-
-(defun quelpa-build--find-source-file (target files)
-  "Search for source of TARGET in FILES."
-  (car (rassoc target files)))
-
-(defun quelpa-build--package-buffer-info-vec ()
-  "Return a vector of package info.
-`package-buffer-info' returns a vector in older Emacs versions,
-and a cl struct in Emacs HEAD.  This wrapper normalises the results."
-  (let ((desc (package-buffer-info))
-        (keywords (lm-keywords-list)))
-    (if (fboundp 'package-desc-create)
-        (let ((extras (package-desc-extras desc)))
-          (when (and keywords (not (assq :keywords extras)))
-            ;; Add keywords to package properties, if not already present
-            (push (cons :keywords keywords) extras))
-          (vector (package-desc-name desc)
-                  (package-desc-reqs desc)
-                  (package-desc-summary desc)
-                  (package-desc-version desc)
-                  extras))
-      ;; The regexp and the processing is taken from `lm-homepage' in Emacs 24.4
-      (let* ((page (lm-header "\\(?:x-\\)?\\(?:homepage\\|url\\)"))
-             (homepage (if (and page (string-match "^<.+>$" page))
-                           (substring page 1 -1)
-                         page))
-             extras)
-        (when keywords (push (cons :keywords keywords) extras))
-        (when homepage (push (cons :url homepage) extras))
-        (vector  (aref desc 0)
-                 (aref desc 1)
-                 (aref desc 2)
-                 (aref desc 3)
-                 extras)))))
-
-;;; Building
-
-;;;###autoload
-(defun quelpa-build-package (package-name version file-specs source-dir target-dir)
-  "Create PACKAGE-NAME with VERSION.
-
-The information in FILE-SPECS is used to gather files from
-SOURCE-DIR.
-
-The resulting package will be stored as a .el or .tar file in
-TARGET-DIR, depending on whether there are multiple files.
-
-Argument FILE-SPECS is a list of specs for source files, which
-should be relative to SOURCE-DIR.  The specs can be wildcards,
-and optionally specify different target paths.  They extended
-syntax is currently only documented in the MELPA README.  You can
-simply pass `quelpa-build-default-files-spec' in most cases.
-
-Returns the archive entry for the package."
-  (when (symbolp package-name)
-    (setq package-name (symbol-name package-name)))
-  (let ((files (quelpa-build-expand-file-specs source-dir file-specs)))
-    (unless (equal file-specs quelpa-build-default-files-spec)
-      (when (equal files (quelpa-build-expand-file-specs
-                          source-dir quelpa-build-default-files-spec nil t))
-        (quelpa-build--message "Note: %s :files spec is equivalent to the default."
-                               package-name)))
-    (cond
-     ((not version)
-      (error "Unable to check out repository for %s" package-name))
-     ((= 1 (length files))
-      (quelpa-build--build-single-file-package
-       package-name version (caar files) source-dir target-dir))
-     ((< 1 (length  files))
-      (quelpa-build--build-multi-file-package
-       package-name version files source-dir target-dir))
-     (t (error "Unable to find files matching recipe patterns")))))
-
-(defun quelpa-build--build-single-file-package
-    (package-name version file source-dir target-dir)
-  (let* ((pkg-source (expand-file-name file source-dir))
-         (pkg-target (expand-file-name
-                      (concat package-name "-" version ".el")
-                      target-dir))
-         (pkg-info (quelpa-build--merge-package-info
-                    (quelpa-build--get-package-info pkg-source)
-                    package-name
-                    version)))
-    (unless (string-equal (downcase (concat package-name ".el"))
-                          (downcase (file-name-nondirectory pkg-source)))
-      (error "Single file %s does not match package name %s"
-             (file-name-nondirectory pkg-source) package-name))
-    (if (file-exists-p pkg-target)
-        (quelpa-build--message "Skipping rebuild of %s" pkg-target)
-      (copy-file pkg-source pkg-target)
-      (let ((enable-local-variables nil)
-            (make-backup-files nil))
-        (with-temp-buffer
-          (insert-file-contents pkg-target)
-          (quelpa-build--update-or-insert-version version)
-          (quelpa-build--ensure-ends-here-line pkg-source)
-          (write-file pkg-target nil)
-          (condition-case err
-              (quelpa-build--package-buffer-info-vec)
-            (error
-             (quelpa-build--message "Warning: %S" err)))))
-
-      (quelpa-build--write-pkg-readme
-       target-dir
-       (quelpa-build--find-package-commentary pkg-source)
-       package-name))
-    (quelpa-build--archive-entry pkg-info 'single)))
-
-(defun quelpa-build--build-multi-file-package
-    (package-name version files source-dir target-dir)
-  (let ((tmp-dir (file-name-as-directory (make-temp-file package-name t))))
-    (unwind-protect
-        (let* ((pkg-dir-name (concat package-name "-" version))
-               (pkg-tmp-dir (expand-file-name pkg-dir-name tmp-dir))
-               (pkg-file (concat package-name "-pkg.el"))
-               (pkg-file-source (or (quelpa-build--find-source-file pkg-file files)
-                                    pkg-file))
-               (file-source (concat package-name ".el"))
-               (pkg-source (or (quelpa-build--find-source-file file-source files)
-                               file-source))
-               (pkg-info (quelpa-build--merge-package-info
-                          (let ((default-directory source-dir))
-                            (or (quelpa-build--get-pkg-file-info pkg-file-source)
-                                ;; some packages (like magit) provide name-pkg.el.in
-                                (quelpa-build--get-pkg-file-info
-                                 (expand-file-name (concat pkg-file ".in")
-                                                   (file-name-directory pkg-source)))
-                                (quelpa-build--get-package-info pkg-source)))
-                          package-name
-                          version)))
-          (quelpa-build--copy-package-files files source-dir pkg-tmp-dir)
-          (quelpa-build--write-pkg-file (expand-file-name
-                                         pkg-file
-                                         (file-name-as-directory pkg-tmp-dir))
-                                        pkg-info)
-
-          (quelpa-build--generate-info-files files source-dir pkg-tmp-dir)
-          (quelpa-build--generate-dir-file files pkg-tmp-dir)
-
-          (let ((default-directory tmp-dir))
-            (quelpa-build--create-tar
-             (expand-file-name (concat package-name "-" version ".tar")
-                               target-dir)
-             pkg-dir-name))
-
-          (let ((default-directory source-dir))
-            (quelpa-build--write-pkg-readme
-             target-dir
-             (quelpa-build--find-package-commentary pkg-source)
-             package-name))
-          (quelpa-build--archive-entry pkg-info 'tar))
-      (delete-directory tmp-dir t nil))))
-
-(defun quelpa-build--checkout-file (name config dir)
-  "Build according to a PATH with config CONFIG into DIR as NAME.
-Generic local file handler for package-build.el.
-
-Handles the following cases:
-
-local file:
-
-Installs a single-file package from a local file.  Use the :path
-attribute with a PATH like \"/path/to/file.el\".
-
-local directory:
-
-Installs a multi-file package from a local directory.  Use
-the :path attribute with a PATH like \"/path/to/dir\"."
-  (quelpa-check-hash name config (expand-file-name (plist-get config :path)) dir))
-
-(defun quelpa-build--checkout-url (name config dir)
-  "Build according to an URL with config CONFIG into DIR as NAME.
-Generic URL handler for package-build.el.
-
-Handles the following cases:
-
-local file:
-
-Installs a single-file package from a local file.  Use the :url
-attribute with an URL like \"file:///path/to/file.el\".
-
-remote file:
-
-Installs a single-file package from a remote file.  Use the :url
-attribute with an URL like \"http://domain.tld/path/to/file.el\"."
-  (let* ((url (plist-get config :url))
-         (remote-file-name (file-name-nondirectory
-                            (url-filename (url-generic-parse-url url))))
-         (local-path (expand-file-name remote-file-name dir))
-         (mm-attachment-file-modes (default-file-modes)))
-    (unless (string= (file-name-extension url) "el")
-      (error "<%s> does not end in .el" url))
-    (unless (file-directory-p dir)
-      (make-directory dir))
-    (url-copy-file url local-path t)
-    (quelpa-check-hash name config local-path dir 'url)))
-
-;; --- helpers ---------------------------------------------------------------
-
-(defun quelpa-message (wait format-string &rest args)
-  "Log a message with FORMAT-STRING and ARGS when `quelpa-verbose' is non-nil.
-If WAIT is nil don't wait after showing the message. If it is a
-number, wait so many seconds. If WAIT is t wait the default time.
-Return t in each case."
-  (when quelpa-verbose
-    (message "Quelpa: %s" (apply 'format format-string args))
-    (when (or (not noninteractive) wait) ; no wait if emacs is noninteractive
-      (sit-for (or (and (numberp wait) wait) 1.5) t)))
-  t)
-
-(defun quelpa-read-cache ()
-  "Read from `quelpa-persistent-cache-file' in `quelpa-cache'."
-  (when (and quelpa-persistent-cache-p
-             (file-exists-p quelpa-persistent-cache-file))
-    (with-temp-buffer
-      (insert-file-contents-literally quelpa-persistent-cache-file)
-      (setq quelpa-cache
-            (read (buffer-substring-no-properties (point-min) (point-max)))))))
-
-(defun quelpa-save-cache ()
-  "Write `quelpa-cache' to `quelpa-persistent-cache-file'."
-  (when quelpa-persistent-cache-p
-    (let (print-level print-length)
-      (with-temp-file quelpa-persistent-cache-file
-        (insert (prin1-to-string quelpa-cache))))))
-
-(defun quelpa-update-cache (cache-item)
-  ;; try removing existing recipes by name
-  (setq quelpa-cache (cl-remove (car cache-item)
-                                quelpa-cache :key #'car))
-  (push cache-item quelpa-cache)
-  (setq quelpa-cache
-        (cl-sort quelpa-cache #'string<
-                 :key (lambda (item) (symbol-name (car item))))))
-
-(defun quelpa-parse-stable (cache-item)
-  ;; in case :stable doesn't originate from PLIST, shadow the
-  ;; default value anyways
-  (when (plist-member (cdr cache-item) :stable)
-    (setq quelpa-stable-p (plist-get (cdr cache-item) :stable)))
-  (when (and quelpa-stable-p (not (plist-get (cdr cache-item) :stable)))
-    (setf (cdr (last cache-item)) '(:stable t))))
-
-(defun quelpa-checkout-melpa ()
-  "Fetch or update the melpa source code from Github.
-If there is no error return non-nil.
-If there is an error but melpa is already checked out return non-nil.
-If there is an error and no existing checkout return nil."
-  (or (and (null quelpa-update-melpa-p)
-           (file-exists-p (expand-file-name ".git" quelpa-melpa-dir)))
-      (condition-case err
-          (quelpa-build--checkout-git
-           'package-build
-           `(:url ,quelpa-melpa-repo-url :files ("*"))
-           quelpa-melpa-dir)
-        (error "failed to checkout melpa git repo: `%s'" (error-message-string err)))))
-
-(defun quelpa-get-melpa-recipe (name)
-  "Read recipe with NAME for melpa git checkout.
-Return the recipe if it exists, otherwise nil."
-  (cl-loop for store in quelpa-melpa-recipe-stores
-           if (stringp store)
-           for file = (assoc-string name (directory-files store nil "^[^\.]+"))
-           when file
-           return (with-temp-buffer
-                    (insert-file-contents-literally
-                     (expand-file-name file store))
-                    (read (buffer-string)))
-           else
-           for rcp = (assoc-string name store)
-           when rcp
-           return rcp))
-
-(defun quelpa-setup-p ()
-  "Setup what we need for quelpa.
-Return non-nil if quelpa has been initialized properly."
-  (catch 'quit
-    (dolist (dir (list quelpa-packages-dir quelpa-build-dir))
-      (unless (file-exists-p dir) (make-directory dir t)))
-    (unless quelpa-initialized-p
-      (quelpa-read-cache)
-      (quelpa-setup-package-structs)
-      (if quelpa-checkout-melpa-p
-          (unless (quelpa-checkout-melpa) (throw 'quit nil)))
-      (setq quelpa-initialized-p t))
-    t))
-
-(defun quelpa-shutdown ()
-  "Do things that need to be done after running quelpa."
-  (quelpa-save-cache)
-  ;; remove the packages dir because we are done with the built pkgs
-  (ignore-errors (delete-directory quelpa-packages-dir t)))
-
-(defun quelpa-arg-rcp (arg)
-  "Given recipe or package name, return an alist '(NAME . RCP).
-If RCP cannot be found it will be set to nil"
-  (pcase arg
-    (`(,a . nil) (quelpa-get-melpa-recipe (car arg)))
-    (`(,a . ,_) arg)
-    ((pred symbolp) (quelpa-get-melpa-recipe arg))))
-
-(defun quelpa-parse-plist (plist)
-  "Parse the optional PLIST argument of `quelpa'.
-Recognized keywords are:
-
-:upgrade
-
-If t, `quelpa' tries to do an upgrade.
-
-:stable
-
-If t, `quelpa' tries building the stable version of a package."
-  (while plist
-    (let ((key (car plist))
-          (value (cadr plist)))
-      (pcase key
-        (:upgrade (setq quelpa-upgrade-p value))
-        (:stable (setq quelpa-stable-p value))))
-    (setq plist (cddr plist))))
-
-(defun quelpa-package-install-file (file)
-  "Workaround problem with `package-install-file'.
-`package-install-file' uses `insert-file-contents-literally'
-which causes problems when the file inserted has crlf line
-endings (Windows). So here we replace that with
-`insert-file-contents' for non-tar files."
-  (if (eq system-type 'windows-nt)
-      (cl-letf* ((insert-file-contents-literally-orig
-                  (symbol-function 'insert-file-contents-literally))
-                 ((symbol-function 'insert-file-contents-literally)
-                  (lambda (file)
-                    (if (string-match "\\.tar\\'" file)
-                        (funcall insert-file-contents-literally-orig file)
-                      (insert-file-contents file)))))
-        (package-install-file file))
-    (package-install-file file)))
-
-(defun quelpa-package-install (arg)
-  "Build and install package from ARG (a recipe or package name).
-If the package has dependencies recursively call this function to
-install them."
-  (let* ((rcp (quelpa-arg-rcp arg))
-         (file (and rcp (quelpa-build rcp))))
-    (when file
-      (let* ((pkg-desc (quelpa-get-package-desc file))
-             (requires (package-desc-reqs pkg-desc)))
-        (when requires
-          (mapc (lambda (req)
-                  (unless (or (equal 'emacs (car req))
-                              (package-installed-p (car req) (cadr req)))
-                    (quelpa-package-install (car req))))
-                requires))
-        (quelpa-package-install-file file)))))
-
-(defun quelpa-interactive-candidate ()
-  "Query the user for a recipe and return the name."
-  (when (quelpa-setup-p)
-    (let  ((recipes (cl-loop
-                     for store in quelpa-melpa-recipe-stores
-                     if (stringp store)
-                     ;; this regexp matches all files except dotfiles
-                     append (directory-files store nil "^[^.].+$")
-                     else if (listp store)
-                     append store)))
-      (intern (completing-read "Choose MELPA recipe: "
-                               recipes nil t)))))
-
-;; --- public interface ------------------------------------------------------
-
-;;;###autoload
-(defun quelpa-expand-recipe (recipe-name)
-  "Expand a given recipe name into full recipe.
-If called interactively, let the user choose a recipe name and
-insert the result into the current buffer."
-  (interactive (list (quelpa-interactive-candidate)))
-  (when (quelpa-setup-p)
-    (let* ((recipe (quelpa-get-melpa-recipe recipe-name)))
-      (when recipe
-        (if (called-interactively-p 'any)
-            (prin1 recipe (current-buffer)))
-        recipe))))
-
-;;;###autoload
-(defun quelpa-self-upgrade (&optional args)
-  "Upgrade quelpa itself.
-ARGS are additional options for the quelpa recipe."
-  (interactive)
-  (when (quelpa-setup-p)
-    (quelpa (append quelpa-recipe args) :upgrade t)))
-
-;;;###autoload
-(defun quelpa-upgrade ()
-  "Upgrade all packages found in `quelpa-cache'.
-This provides an easy way to upgrade all the packages for which
-the `quelpa' command has been run in the current Emacs session."
-  (interactive)
-  (when (quelpa-setup-p)
-    (let ((quelpa-upgrade-p t))
-      (when quelpa-self-upgrade-p
-        (quelpa-self-upgrade))
-      (setq quelpa-cache
-            (cl-remove-if-not #'package-installed-p quelpa-cache :key #'car))
-      (mapc (lambda (item)
-              (when (package-installed-p (car (quelpa-arg-rcp item)))
-                (quelpa item)))
-            quelpa-cache))))
-
-;;;###autoload
-(defun quelpa (arg &rest plist)
-  "Build and install a package with quelpa.
-ARG can be a package name (symbol) or a melpa recipe (list).
-PLIST is a plist that may modify the build and/or fetch process.
-If called interactively, `quelpa' will prompt for a MELPA package
-to install.
-
-When `quelpa' is called interactively with a prefix argument (e.g
-C-u M-x quelpa) it will try to upgrade the given package even if
-the global var `quelpa-upgrade-p' is set to nil."
-
-  (interactive (list (quelpa-interactive-candidate)))
-  (run-hooks 'quelpa-before-hook)
-  (when (quelpa-setup-p) ;if init fails we do nothing
-    (let* ((quelpa-upgrade-p (if current-prefix-arg t quelpa-upgrade-p)) ;shadow `quelpa-upgrade-p'
-           (quelpa-stable-p quelpa-stable-p) ;shadow `quelpa-stable-p'
-           (cache-item (if (symbolp arg) (list arg) arg)))
-      (quelpa-parse-plist plist)
-      (quelpa-parse-stable cache-item)
-      (quelpa-package-install arg)
-      (quelpa-update-cache cache-item)))
-  (quelpa-shutdown)
-  (run-hooks 'quelpa-after-hook))
-
-(provide 'quelpa)
-
-;;; quelpa.el ends here