about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/async-20180527.1730/async-bytecomp.el
blob: 7bb2d46a20f3e8f6ab56ce9adb7e6830c080f55b (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
;;; async-bytecomp.el --- Compile elisp files asynchronously -*- lexical-binding: t -*-

;; Copyright (C) 2014-2016 Free Software Foundation, Inc.

;; Authors: John Wiegley <jwiegley@gmail.com>
;;          Thierry Volpiatto <thierry.volpiatto@gmail.com>

;; Keywords: dired async byte-compile
;; X-URL: https://github.com/jwiegley/dired-async

;; 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 2, 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 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:
;;
;;  This package provide the `async-byte-recompile-directory' function
;;  which allows, as the name says to recompile a directory outside of
;;  your running emacs.
;;  The benefit is your files will be compiled in a clean environment without
;;  the old *.el files loaded.
;;  Among other things, this fix a bug in package.el which recompile
;;  the new files in the current environment with the old files loaded, creating
;;  errors in most packages after upgrades.
;;
;;  NB: This package is advicing the function `package--compile'.

;;; Code:

(require 'cl-lib)
(require 'async)

(defcustom async-bytecomp-allowed-packages
  '(async helm helm-core helm-ls-git helm-ls-hg magit)
  "Packages in this list will be compiled asynchronously by `package--compile'.
All the dependencies of these packages will be compiled async too,
so no need to add dependencies to this list.
The value of this variable can also be a list with a single element,
the symbol `all', in this case packages are always compiled asynchronously."
  :group 'async
  :type '(repeat (choice symbol)))

(defvar async-byte-compile-log-file
  (concat user-emacs-directory "async-bytecomp.log"))

;;;###autoload
(defun async-byte-recompile-directory (directory &optional quiet)
  "Compile all *.el files in DIRECTORY asynchronously.
All *.elc files are systematically deleted before proceeding."
  (cl-loop with dir = (directory-files directory t "\\.elc\\'")
           unless dir return nil
           for f in dir
           when (file-exists-p f) do (delete-file f))
  ;; Ensure async is reloaded when async.elc is deleted.
  ;; This happen when recompiling its own directory.
  (load "async")
  (let ((call-back
         (lambda (&optional _ignore)
           (if (file-exists-p async-byte-compile-log-file)
               (let ((buf (get-buffer-create byte-compile-log-buffer))
                     (n 0))
                 (with-current-buffer buf
                   (goto-char (point-max))
                   (let ((inhibit-read-only t))
                     (insert-file-contents async-byte-compile-log-file)
                     (compilation-mode))
                   (display-buffer buf)
                   (delete-file async-byte-compile-log-file)
                   (unless quiet
                     (save-excursion
                       (goto-char (point-min))
                       (while (re-search-forward "^.*:Error:" nil t)
                         (cl-incf n)))
                     (if (> n 0)
                         (message "Failed to compile %d files in directory `%s'" n directory)
                         (message "Directory `%s' compiled asynchronously with warnings" directory)))))
               (unless quiet
                 (message "Directory `%s' compiled asynchronously with success" directory))))))
    (async-start
     `(lambda ()
        (require 'bytecomp)
        ,(async-inject-variables "\\`\\(load-path\\)\\|byte\\'")
        (let ((default-directory (file-name-as-directory ,directory))
              error-data)
          (add-to-list 'load-path default-directory)
          (byte-recompile-directory ,directory 0 t)
          (when (get-buffer byte-compile-log-buffer)
            (setq error-data (with-current-buffer byte-compile-log-buffer
                               (buffer-substring-no-properties (point-min) (point-max))))
            (unless (string= error-data "")
              (with-temp-file ,async-byte-compile-log-file
                (erase-buffer)
                (insert error-data))))))
     call-back)
    (unless quiet (message "Started compiling asynchronously directory %s" directory))))

(defvar package-archive-contents)
(defvar package-alist)
(declare-function package-desc-reqs "package.el" (cl-x))

(defun async-bytecomp--get-package-deps (pkg &optional only)
  ;; Same as `package--get-deps' but parse instead `package-archive-contents'
  ;; because PKG is not already installed and not present in `package-alist'.
  ;; However fallback to `package-alist' in case PKG no more present
  ;; in `package-archive-contents' due to modification to `package-archives'.
  ;; See issue #58.
  (let* ((pkg-desc (cadr (or (assq pkg package-archive-contents)
                             (assq pkg package-alist))))
         (direct-deps (cl-loop for p in (package-desc-reqs pkg-desc)
                               for name = (car p)
                               when (or (assq name package-archive-contents)
                                        (assq name package-alist))
                               collect name))
         (indirect-deps (unless (eq only 'direct)
                          (delete-dups
                           (cl-loop for p in direct-deps append
                                    (async-bytecomp--get-package-deps p))))))
    (cl-case only
      (direct   direct-deps)
      (separate (list direct-deps indirect-deps))
      (indirect indirect-deps)
      (t        (delete-dups (append direct-deps indirect-deps))))))

(defun async-bytecomp-get-allowed-pkgs ()
  (when (and async-bytecomp-allowed-packages
             (listp async-bytecomp-allowed-packages))
    (if package-archive-contents
        (cl-loop for p in async-bytecomp-allowed-packages
                 when (assq p package-archive-contents)
                 append (async-bytecomp--get-package-deps p) into reqs
                 finally return
                 (delete-dups
                  (append async-bytecomp-allowed-packages reqs)))
        async-bytecomp-allowed-packages)))

(defadvice package--compile (around byte-compile-async)
  (let ((cur-package (package-desc-name pkg-desc))
        (pkg-dir (package-desc-dir pkg-desc)))
    (if (or (equal async-bytecomp-allowed-packages '(all))
            (memq cur-package (async-bytecomp-get-allowed-pkgs)))
        (progn
          (when (eq cur-package 'async)
            (fmakunbound 'async-byte-recompile-directory))
          ;; Add to `load-path' the latest version of async and
          ;; reload it when reinstalling async.
          (when (string= cur-package "async")
            (cl-pushnew pkg-dir load-path)
            (load "async-bytecomp"))
          ;; `async-byte-recompile-directory' will add directory
          ;; as needed to `load-path'.
          (async-byte-recompile-directory (package-desc-dir pkg-desc) t))
        ad-do-it)))

;;;###autoload
(define-minor-mode async-bytecomp-package-mode
    "Byte compile asynchronously packages installed with package.el.
Async compilation of packages can be controlled by
`async-bytecomp-allowed-packages'."
  :group 'async
  :global t
  (if async-bytecomp-package-mode
      (ad-activate 'package--compile)
      (ad-deactivate 'package--compile)))

;;;###autoload
(defun async-byte-compile-file (file)
  "Byte compile Lisp code FILE asynchronously.

Same as `byte-compile-file' but asynchronous."
  (interactive "fFile: ")
  (let ((call-back
         (lambda (&optional _ignore)
           (let ((bn (file-name-nondirectory file)))
             (if (file-exists-p async-byte-compile-log-file)
                 (let ((buf (get-buffer-create byte-compile-log-buffer))
                       start)
                   (with-current-buffer buf
                     (goto-char (setq start (point-max)))
                     (let ((inhibit-read-only t))
                       (insert-file-contents async-byte-compile-log-file)
                       (compilation-mode))
                     (display-buffer buf)
                     (delete-file async-byte-compile-log-file)
                     (save-excursion
                       (goto-char start)
                       (if (re-search-forward "^.*:Error:" nil t)
                           (message "Failed to compile `%s'" bn)
                         (message "`%s' compiled asynchronously with warnings" bn)))))
               (message "`%s' compiled asynchronously with success" bn))))))
    (async-start
     `(lambda ()
        (require 'bytecomp)
        ,(async-inject-variables "\\`load-path\\'")
        (let ((default-directory ,(file-name-directory file)))
          (add-to-list 'load-path default-directory)
          (byte-compile-file ,file)
          (when (get-buffer byte-compile-log-buffer)
            (setq error-data (with-current-buffer byte-compile-log-buffer
                               (buffer-substring-no-properties (point-min) (point-max))))
            (unless (string= error-data "")
              (with-temp-file ,async-byte-compile-log-file
                (erase-buffer)
                (insert error-data))))))
     call-back)))

(provide 'async-bytecomp)

;;; async-bytecomp.el ends here