forked from technomancy/emacs-starter-kit
/
package.el
1448 lines (1302 loc) · 57.9 KB
/
package.el
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
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
;;; package.el --- Simple package system for Emacs
;; Copyright (C) 2007, 2008, 2009 Tom Tromey <tromey@redhat.com>
;; Author: Tom Tromey <tromey@redhat.com>
;; Created: 10 Mar 2007
;; Version: 0.9.4
;; Keywords: tools
;; This file is not (yet) part of GNU Emacs.
;; However, it is distributed under the same license.
;; 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, 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; see the file COPYING. If not, write to the
;; Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
;; Boston, MA 02110-1301, USA.
;;; Commentary:
;; To use this, put package.el somewhere on your load-path. Then add
;; this to your .emacs:
;;
;; (load "package")
;; (package-initialize)
;;
;; This will automatically make available the packages you have
;; installed using package.el. If your .emacs will refer to these
;; packages, you may want to initialize the package manager near the
;; top.
;;
;; Note that if you want to be able to automatically download and
;; install packages from ELPA (the Emacs Lisp Package Archive), then
;; you will need the 'url' package. This comes with Emacs 22; Emacs
;; 21 users will have to find it elsewhere.
;;
;; If you installed package.el via the auto-installer:
;;
;; http://tromey.com/elpa/
;;
;; then you do not need to edit your .emacs, as the installer will
;; have done this for you. The installer will also install the url
;; package if you need it.
;; Other external functions you may want to use:
;;
;; M-x package-list-packages
;; Enters a mode similar to buffer-menu which lets you manage
;; packages. You can choose packages for install (mark with "i",
;; then "x" to execute) or deletion (not implemented yet), and you
;; can see what packages are available. This will automatically
;; fetch the latest list of packages from ELPA.
;;
;; M-x package-list-packages-no-fetch
;; Like package-list-packages, but does not automatically fetch the
;; new list of packages.
;;
;; M-x package-install-from-buffer
;; Install a package consisting of a single .el file that appears
;; in the current buffer. This only works for packages which
;; define a Version header properly; package.el also supports the
;; extension headers Package-Version (in case Version is an RCS id
;; or similar), and Package-Requires (if the package requires other
;; packages).
;;
;; M-x package-install-file
;; Install a package from the indicated file. The package can be
;; either a tar file or a .el file. A tar file must contain an
;; appropriately-named "-pkg.el" file; a .el file must be properly
;; formatted as with package-install-from-buffer.
;; The idea behind package.el is to be able to download packages and
;; install them. Packages are versioned and have versioned
;; dependencies. Furthermore, this supports built-in packages which
;; may or may not be newer than user-specified packages. This makes
;; it possible to upgrade Emacs and automatically disable packages
;; which have moved from external to core. (Note though that we don't
;; currently register any of these, so this feature does not actually
;; work.)
;; This code supports a single package repository out of the box,
;; ELPA. Additional repositories may be added by appending to the
;; package-archives alist. To run your own package archive, see the
;; package-maint.el library included.
;; A package is described by its name and version. The distribution
;; format is either a tar file or a single .el file.
;; A tar file should be named "NAME-VERSION.tar". The tar file must
;; unpack into a directory named after the package and version:
;; "NAME-VERSION". It must contain a file named "PACKAGE-pkg.el"
;; which consists of a call to define-package. It may also contain a
;; "dir" file and the info files it references.
;; A .el file will be named "NAME-VERSION.el" in ELPA, but will be
;; installed as simply "NAME.el" in a directory named "NAME-VERSION".
;; The downloader will download all dependent packages. It will also
;; byte-compile the package's Lisp at install time.
;; At activation time we will set up the load-path and the info path,
;; and we will load the package's autoloads. If a package's
;; dependencies are not available, we will not activate that package.
;; Conceptually a package has multiple state transitions:
;;
;; * Download. Fetching the package from its source.
;; * Install. Untar the package, or write the .el file, into
;; ~/.emacs.d/elpa/ directory.
;; * Byte compile. Currently this phase is done during install,
;; but we may change this.
;; * Activate. Evaluate the autoloads for the package to make it
;; available to the user.
;; * Load. Actually load the package and run some code from it.
;;; Thanks:
;;; (sorted by sort-lines):
;; Jim Blandy <jimb@red-bean.com>
;; Karl Fogel <kfogel@red-bean.com>
;; Kevin Ryde <user42@zip.com.au>
;; Lawrence Mitchell
;; Michael Olson <mwolson@member.fsf.org>
;; Sebastian Tennant <sebyte@smolny.plus.com>
;; Stefan Monnier <monnier@iro.umontreal.ca>
;; Vinicius Jose Latorre <viniciusjl@ig.com.br>
;; Phil Hagelberg <phil@hagelb.org>
;; Samuel Bronson <naesten@gmail.com>
;;; History:
;;
;; Originally written by Tom Tromey, multiple archive support added by Phil
;; Hagelberg.
;;; Code:
(defcustom package-archives '(("elpa" . "http://tromey.com/elpa/"))
"An alist of archives (names and URLs) from which to fetch.
The default points to ELPA, the Emacs Lisp Package Archive.
Note that some code in package.el assumes that this is an http: URL."
:type '(alist :key-type (string :tag "Archive name")
:value-type (string :tag "Archive URL"))
:group 'package
:package-version '("package.el" . "0.9.3"))
(defconst package-archive-version 1
"Version number of the package archive understood by this file.
Lower version numbers than this will probably be understood as well.")
(defconst package-el-version "0.9.4"
"Version of package.el.")
;; We don't prime the cache since it tends to get out of date.
(defvar package-archive-contents
nil
"A representation of the contents of the ELPA archive.
This is an alist mapping package names (symbols) to package
descriptor vectors. These are like the vectors for `package-alist'
but have extra entries: one which is 'tar for tar packages and
'single for single-file packages, and one which is the name of
the archive from which it came.")
(defvar package-user-dir
(expand-file-name (convert-standard-filename "~/.emacs.d/elpa"))
"Name of the directory where the user's packages are stored.")
(defvar package-directory-list
(list (file-name-as-directory package-user-dir)
"/usr/share/emacs/site-lisp/elpa/")
"List of directories to search for packages.")
(defun package-version-split (string)
"Split a package STRING into a version list."
(mapcar 'string-to-int (split-string string "[.]")))
(defconst package--builtins-base
;; We use package-version split here to make sure to pick up the
;; minor version.
`((emacs . [,(package-version-split emacs-version) nil
"GNU Emacs"])
(package . [,(package-version-split package-el-version)
nil "Simple package system for GNU Emacs"]))
"Packages which are always built-in.")
(defvar package--builtins
(delq nil
(append
package--builtins-base
(if (>= emacs-major-version 22)
;; FIXME: emacs 22 includes tramp, rcirc, maybe
;; other things...
'((erc . [(5 2) nil "An Emacs Internet Relay Chat client"])
;; The external URL is version 1.15, so make sure the
;; built-in one looks newer.
(url . [(1 16) nil "URL handling libary"])))
(if (>= emacs-major-version 23)
'(;; Strangely, nxml-version is missing in Emacs 23.
;; We pick the merge date as the version.
(nxml . [(20071123) nil "Major mode for editing XML documents."])
(bubbles . [(0 5) nil "Puzzle game for Emacs."])))))
"Alist of all built-in packages.
Maps the package name to a vector [VERSION REQS DOCSTRING].")
(defvar package-alist package--builtins
"Alist of all packages available for activation.
Maps the package name to a vector [VERSION REQS DOCSTRING].")
(defvar package-activated-list
(mapcar #'car package-alist)
"List of the names of all activated packages.")
(defvar package-obsolete-alist nil
"Representation of obsolete packages.
Like `package-alist', but maps package name to a second alist.
The inner alist is keyed by version.")
(defun package-version-join (l)
"Turn a list L of version numbers into a version string."
(mapconcat 'int-to-string l "."))
(defun package--version-first-nonzero (l)
"Find the first non-zero number in the list L.
Returns the value of the first non-zero integer in L, or 0 if
none is found."
(while (and l (= (car l) 0))
(setq l (cdr l)))
(if l (car l) 0))
(defun package-version-compare (v1 v2 fun)
"Compare two version V1 and V2 lists according to FUN.
FUN can be <, <=, =, >, >=, or /=."
(while (and v1 v2 (= (car v1) (car v2)))
(setq v1 (cdr v1)
v2 (cdr v2)))
(if v1
(if v2
;; Both not null; we know the cars are not =.
(funcall fun (car v1) (car v2))
;; V1 not null, V2 null.
(funcall fun (package--version-first-nonzero v1) 0))
(if v2
;; V1 null, V2 not null.
(funcall fun 0 (package--version-first-nonzero v2))
;; Both null.
(funcall fun 0 0))))
(defun package--test-version-compare ()
"Test suite for `package-version-compare'."
(unless (and (package-version-compare '(0) '(0) '=)
(not (package-version-compare '(1) '(0) '=))
(package-version-compare '(1 0 1) '(1) '>=)
(package-version-compare '(1 0 1) '(1) '>)
(not (package-version-compare '(0 9 1) '(1 0 2) '>=)))
(error "Failed"))
t)
(defun package-strip-version (dirname)
"Strip the version from a combined package name and version.
E.g., if DIRNAME is \"quux-23.0\", will return \"quux\""
(if (string-match "^\\(.*\\)-[0-9]+\\([.][0-9]+\\)*$" dirname)
(match-string 1 dirname)))
(defun package-load-descriptor (dir package)
"Load the description file in directory DIR for a PACKAGE.
Return nil if the package could not be found."
(let* ((pkg-dir (expand-file-name package dir))
(pkg-file (expand-file-name
(concat (package-strip-version package) "-pkg") pkg-dir)))
(when (and (file-directory-p pkg-dir)
(file-exists-p (concat pkg-file ".el")))
(load pkg-file nil t))))
(defun package-load-all-descriptors ()
"Load descriptors of all packages.
Uses `package-directory-list' to find packages."
(mapc (lambda (dir)
(if (file-directory-p dir)
(mapc (lambda (name)
(package-load-descriptor dir name))
(directory-files dir nil "^[^.]"))))
package-directory-list))
(defsubst package-desc-vers (desc)
"Extract version from a package description vector DESC."
(aref desc 0))
(defsubst package-desc-reqs (desc)
"Extract requirements from a package description vector DESC."
(aref desc 1))
(defsubst package-desc-doc (desc)
"Extract doc string from a package description vector DESC."
(aref desc 2))
(defsubst package-desc-kind (desc)
"Extract the kind of download from an archive package description vector DESC."
(aref desc 3))
(defun package-do-activate (package pkg-vec)
"Set up a single PACKAGE.
Modifies `load-path' to include the package directory and loads
the `autoload' file for the package. PKG-VEC is the package info
as retrieved from the package mirror."
(let* ((pkg-name (symbol-name package))
(pkg-ver-str (package-version-join (package-desc-vers pkg-vec)))
(dir-list package-directory-list)
(pkg-dir))
(while dir-list
(let ((subdir (concat (car dir-list) pkg-name "-" pkg-ver-str "/")))
(if (file-directory-p subdir)
(progn
(setq pkg-dir subdir)
(setq dir-list nil))
(setq dir-list (cdr dir-list)))))
(unless pkg-dir
(error "Internal error: could not find directory for %s-%s"
pkg-name pkg-ver-str))
(if (file-exists-p (concat pkg-dir "dir"))
(progn
;; FIXME: not the friendliest, but simple.
(require 'info)
(info-initialize)
(setq Info-directory-list (cons pkg-dir Info-directory-list))))
(setq load-path (cons pkg-dir load-path))
;; Load the autoloads and activate the package.
(load (concat pkg-dir (symbol-name package) "-autoloads")
nil t)
(setq package-activated-list (cons package package-activated-list))
;; Don't return nil.
t))
(defun package--built-in (package version)
"Return true if PACKAGE at VERSION is built-in to Emacs."
(let ((elt (assq package package--builtins)))
(and elt
(package-version-compare (package-desc-vers (cdr elt)) version '=))))
;; FIXME: return a reason instead?
(defun package-activate (package version)
"Try to activate PACKAGE at version VERSION.
Return nil if the package could not be activated.
Recursively activates all dependencies of the named package."
;; Assume the user knows what he is doing -- go ahead and activate a
;; newer version of a package if an older one has already been
;; activated. This is not ideal; we'd at least need to check to see
;; if the package has actually been loaded, and not merely
;; activated. However, don't try to activate 'emacs', as that makes
;; no sense.
(unless (eq package 'emacs)
(let* ((pkg-desc (assq package package-alist))
(this-version (package-desc-vers (cdr pkg-desc)))
(req-list (package-desc-reqs (cdr pkg-desc)))
;; If the package was never activated, we want to do it
;; now.
(keep-going (or (not (memq package package-activated-list))
(package-version-compare this-version version '>))))
(while (and req-list keep-going)
(or (package-activate (car (car req-list))
(car (cdr (car req-list))))
(setq keep-going nil))
(setq req-list (cdr req-list)))
(if keep-going
(package-do-activate package (cdr pkg-desc))
;; We get here if a dependency failed to activate -- but we
;; can also get here if the requested package was already
;; activated. Return non-nil in the latter case.
(and (memq package package-activated-list)
(package-version-compare this-version version '>=))))))
(defun package-mark-obsolete (package pkg-vec)
"Put PACKAGE on the obsolete list, if not already there.
PKG-VEC describes the version of PACKAGE to mark obsolete."
(let ((elt (assq package package-obsolete-alist)))
(if elt
;; If this obsolete version does not exist in the list, update
;; it the list.
(unless (assoc (package-desc-vers pkg-vec) (cdr elt))
(setcdr elt (cons (cons (package-desc-vers pkg-vec) pkg-vec)
(cdr elt))))
;; Make a new association.
(setq package-obsolete-alist
(cons (cons package (list (cons (package-desc-vers pkg-vec)
pkg-vec)))
package-obsolete-alist)))))
;; (define-package "emacs" "21.4.1" "GNU Emacs core package.")
;; (define-package "erc" "5.1" "ERC - irc client" '((emacs "21.0")))
(defun define-package (name-str version-string
&optional docstring requirements)
"Define a new package.
NAME-STR is the name of the package, a string.
VERSION-STRING is the version of the package, a dotted sequence
of integers.
DOCSTRING is the optional description.
REQUIREMENTS is a list of requirements on other packages.
Each requirement is of the form (OTHER-PACKAGE \"VERSION\")."
(let* ((name (intern name-str))
(pkg-desc (assq name package-alist))
(new-version (package-version-split version-string))
(new-pkg-desc
(cons name
(vector new-version
(mapcar
(lambda (elt)
(list (car elt)
(package-version-split (car (cdr elt)))))
requirements)
docstring))))
;; Only redefine a package if the redefinition is newer.
(if (or (not pkg-desc)
(package-version-compare new-version
(package-desc-vers (cdr pkg-desc))
'>))
(progn
(when pkg-desc
;; Remove old package and declare it obsolete.
(setq package-alist (delq pkg-desc package-alist))
(package-mark-obsolete (car pkg-desc) (cdr pkg-desc)))
;; Add package to the alist.
(setq package-alist (cons new-pkg-desc package-alist)))
;; You can have two packages with the same version, for instance
;; one in the system package directory and one in your private
;; directory. We just let the first one win.
(unless (package-version-compare new-version
(package-desc-vers (cdr pkg-desc))
'=)
;; The package is born obsolete.
(package-mark-obsolete (car new-pkg-desc) (cdr new-pkg-desc))))))
;; From Emacs 22.
(defun package-autoload-ensure-default-file (file)
"Make sure that the autoload file FILE exists and if not create it."
(unless (file-exists-p file)
(write-region
(concat ";;; " (file-name-nondirectory file)
" --- automatically extracted autoloads\n"
";;\n"
";;; Code:\n\n"
" \n;; Local Variables:\n"
";; version-control: never\n"
";; no-byte-compile: t\n"
";; no-update-autoloads: t\n"
";; End:\n"
";;; " (file-name-nondirectory file)
" ends here\n")
nil file))
file)
(defun package-generate-autoloads (name pkg-dir)
"Generate autoload definitions for package NAME in PKG-DIR."
(let* ((auto-name (concat name "-autoloads.el"))
(ignore-name (concat name "-pkg.el"))
(generated-autoload-file (concat pkg-dir auto-name))
(version-control 'never))
;; In Emacs 22 `update-directory-autoloads' does not seem
;; to be autoloaded...
(require 'autoload)
(unless (fboundp 'autoload-ensure-default-file)
(package-autoload-ensure-default-file generated-autoload-file))
(update-directory-autoloads pkg-dir)))
(defun package-untar-buffer ()
"Untar the current buffer.
This uses `tar-untar-buffer' if it is available.
Otherwise it uses an external `tar' program.
`default-directory' should be set by the caller."
(require 'tar-mode)
(if (fboundp 'tar-untar-buffer)
(progn
;; tar-mode messes with narrowing, so we just let it have the
;; whole buffer to play with.
(delete-region (point-min) (point))
(tar-mode)
(tar-untar-buffer))
;; FIXME: check the result.
(call-process-region (point) (point-max) "tar" nil '(nil nil) nil
"xf" "-")))
(defun package-unpack (name version)
"Unpack a package tar from the current buffer.
Unpack the package, using NAME and VERSION to determine the
target. The current buffer is expected to contain a tarred
package archive."
(let ((pkg-dir (concat (file-name-as-directory package-user-dir)
(symbol-name name) "-" version "/")))
;; Be careful!!
(make-directory package-user-dir t)
(if (file-directory-p pkg-dir)
(mapc (lambda (file) nil) ; 'delete-file -- FIXME: when we're
; more confident
(directory-files pkg-dir t "^[^.]")))
(let* ((default-directory (file-name-as-directory package-user-dir)))
(package-untar-buffer)
(package-generate-autoloads (symbol-name name) pkg-dir)
(let ((load-path (cons pkg-dir load-path)))
(byte-recompile-directory pkg-dir 0 t)))))
(defun package-write-file-no-coding (file-name excl)
(let ((buffer-file-coding-system 'no-conversion))
(write-region (point-min) (point-max) file-name nil nil nil excl)))
(defun package-unpack-single (file-name version desc requires)
"Install the contents of the current buffer as a package.
FILE-NAME is the name of the current file being unpacked.
package.el itself is handled specially, so this information is
important.
VERSION is the version (as a string) of the file being unpacked.
DESC is a brief description of the package.
REQUIRES is a list of symbols which this package needs to run."
(let* ((dir (file-name-as-directory package-user-dir)))
;; Special case "package".
(if (string= file-name "package")
(package-write-file-no-coding (concat dir file-name ".el") nil)
(let ((pkg-dir (file-name-as-directory
(concat dir file-name "-" version))))
(make-directory pkg-dir t)
(package-write-file-no-coding (concat pkg-dir file-name ".el") 'excl)
(let ((print-level nil)
(print-length nil))
(write-region
(concat
(prin1-to-string
(list 'define-package
file-name
version
desc
(list 'quote
;; Turn version lists into string form.
(mapcar
(lambda (elt)
(list (car elt)
(package-version-join (car (cdr elt)))))
requires))))
"\n")
nil
(concat pkg-dir file-name "-pkg.el")
nil nil nil 'excl))
(package-generate-autoloads file-name pkg-dir)
(let ((load-path (cons pkg-dir load-path)))
(byte-recompile-directory pkg-dir 0 t))))))
(defun package-handle-response ()
"Handle the response from the server.
Parse the HTTP response and throw if an error occurred.
The url package seems to require extra processing for this.
This should be called in a `save-excursion', in the download buffer.
It will move point to somewhere in the headers."
(let ((type (url-type url-current-object)))
(cond
((equal type "http")
(let ((response (url-http-parse-response)))
(when (or (< response 200) (>= response 300))
(display-buffer (current-buffer))
(error "Error during download request:%s"
(buffer-substring-no-properties (point) (progn
(end-of-line)
(point)))))))
((equal type "file")
nil))))
(defun package-download-single (name version desc requires)
"Download and install a single-file package.
NAME, VERSION, DESC, and REQUIRES are used to build the package
info."
(let ((buffer (url-retrieve-synchronously
(concat (package-archive-for name)
(symbol-name name) "-" version ".el"))))
(save-excursion
(set-buffer buffer)
(package-handle-response)
(re-search-forward "^$" nil 'move)
(forward-char)
(delete-region (point-min) (point))
(package-unpack-single (symbol-name name) version desc requires)
(kill-buffer buffer))))
(defun package-download-tar (name version)
"Download and install a tar package NAME at VERSION."
(let ((tar-buffer (url-retrieve-synchronously
(concat (package-archive-for name)
(symbol-name name) "-" version ".tar"))))
(save-excursion
(set-buffer tar-buffer)
(package-handle-response)
;; Skip past url-retrieve headers, which would otherwise confuse poor
;; tar-mode.
(goto-char (point-min))
(re-search-forward "^$" nil 'move)
(forward-char)
(package-unpack name version)
(kill-buffer tar-buffer))))
(defun package-installed? (package &optional min-version)
"Check whether PACKAGE is installed and at least MIN-VERSION."
(let ((pkg-desc (assq package package-alist)))
(and pkg-desc
(package-version-compare min-version
(package-desc-vers (cdr pkg-desc))
'<=))))
(defun package-compute-transaction (result requirements)
"Recursively prepare a transaction, resolving dependencies.
RESULT is a flattened list of packages to install.
`package-compute-transaction' recursively builds this argument
before passing it up to the caller.
REQUIREMENTS is a list of required packages, to be recursively
processed to resolve all dependencies (if possible)."
(while requirements
(let* ((elt (car requirements))
(next-pkg (car elt))
(next-version (car (cdr elt))))
(unless (package-installed? next-pkg next-version)
(let ((pkg-desc (assq next-pkg package-archive-contents)))
(unless pkg-desc
(error "Package '%s' not available for installation"
(symbol-name next-pkg)))
(unless (package-version-compare (package-desc-vers (cdr pkg-desc))
next-version
'>=)
(error
"Need package '%s' with version %s, but only %s is available"
(symbol-name next-pkg) (package-version-join next-version)
(package-version-join (package-desc-vers (cdr pkg-desc)))))
;; Only add to the transaction if we don't already have it.
(unless (memq next-pkg result)
(setq result (cons next-pkg result)))
(setq result
(package-compute-transaction result
(package-desc-reqs
(cdr pkg-desc)))))))
(setq requirements (cdr requirements)))
result)
(defun package-read-from-string (str)
"Read a Lisp expression from STR.
Signal an error if the entire string was not used."
(let* ((read-data (read-from-string str))
(more-left
(condition-case nil
;; The call to `ignore' suppresses a compiler warning.
(progn (ignore (read-from-string
(substring str (cdr read-data))))
t)
(end-of-file nil))))
(if more-left
(error "Can't read whole string")
(car read-data))))
(defun package--read-archive-file (file)
"Re-read archive file FILE, if it exists.
Will return the data from the file, or nil if the file does not exist.
Will throw an error if the archive version is too new."
(let ((filename (concat (file-name-as-directory package-user-dir)
file)))
(if (file-exists-p filename)
(with-temp-buffer
(insert-file-contents-literally filename)
(let ((contents (package-read-from-string
(buffer-substring-no-properties (point-min)
(point-max)))))
(if (> (car contents) package-archive-version)
(error "Package archive version %d is greater than %d - upgrade package.el"
(car contents) package-archive-version))
(cdr contents))))))
(defun package-read-all-archive-contents ()
"Read the archive description of each of the archives in `package-archives'."
(dolist (archive package-archives)
(package-read-archive-contents (car archive)))
(let ((builtins (package--read-archive-file
(concat "archives/" (caar package-archives)
"/builtin-packages"))))
(if builtins
;; Version 1 of 'builtin-packages' is a list where the car is
;; a split emacs version and the cdr is an alist suitable for
;; package--builtins.
(let ((our-version (package-version-split emacs-version))
(result package--builtins-base))
(setq package--builtins
(dolist (elt builtins result)
(if (package-version-compare our-version (car elt) '>=)
(setq result (append (cdr elt) result)))))))))
(defun package-read-archive-contents (archive)
"Re-read `archive-contents' and `builtin-packages', for ARCHIVE if they exist.
Will set `package-archive-contents' and `package--builtins' if
successful. Will throw an error if the archive version is too
new."
(let ((archive-contents (package--read-archive-file
(concat "archives/" archive
"/archive-contents"))))
(if archive-contents
;; Version 1 of 'archive-contents' is identical to our
;; internal representation.
;; TODO: merge archive lists
(dolist (package archive-contents)
(package--add-to-archive-contents package archive)))))
(defun package--add-to-archive-contents (package archive)
"Add the PACKAGE from the given ARCHIVE if needed.
Adds the archive from which it came to the end of the package vector."
(let* ((package-name (car package))
(package-version (aref (cdr package) 0))
(package-with-archive (cons (car package)
(vconcat (cdr package) (vector archive))))
(existing-package (cdr (assq package-name package-archive-contents))))
(when (or (not existing-package)
(package-version-compare package-version
(aref existing-package 0) '>))
(add-to-list 'package-archive-contents package-with-archive))))
(defun package-download-transaction (transaction)
"Download and install all the packages in the given TRANSACTION."
(mapc (lambda (elt)
(let* ((desc (cdr (assq elt package-archive-contents)))
(v-string (package-version-join (package-desc-vers desc)))
(kind (package-desc-kind desc)))
(cond
((eq kind 'tar)
(package-download-tar elt v-string))
((eq kind 'single)
(package-download-single elt v-string
(package-desc-doc desc)
(package-desc-reqs desc)))
(t
(error "Unknown package kind: " (symbol-name kind))))))
transaction))
(defun package-install (name)
"Install the package named NAME.
Interactively, prompts for the package name."
(interactive
(list (progn
(intern (completing-read "Install package: "
(mapcar (lambda (elt)
(cons (symbol-name (car elt))
nil))
package-archive-contents)
nil t)))))
(let ((pkg-desc (assq name package-archive-contents)))
(unless pkg-desc
(error "Package '%s' not available for installation"
(symbol-name name)))
(let ((transaction
(package-compute-transaction (list name)
(package-desc-reqs (cdr pkg-desc)))))
(package-download-transaction transaction)))
;; Try to activate it.
(package-initialize))
(defun package-strip-rcs-id (v-str)
"Strip RCS version ID from the version string V-STR.
If the result looks like a dotted numeric version, return it.
Otherwise return nil."
(if v-str
(if (string-match "[ \t]*\\$\\(?:Revision\\|Id\\):[ \t]\\(?:[^ \t]+,v[ \t]+\\)?\\([0-9.]+\\).*\\$$" v-str)
(match-string 1 v-str)
(if (string-match "^[0-9.]*$" v-str)
v-str))))
(defun package-buffer-info ()
"Return a vector of information about the package in the current buffer.
The vector looks like [FILENAME REQUIRES DESCRIPTION VERSION COMMENTARY]
FILENAME is the file name, a string. It does not have the \".el\" extension.
REQUIRES is a requires list, or nil.
DESCRIPTION is the package description (a string).
VERSION is the version, a string.
COMMENTARY is the commentary section, a string, or nil if none.
Throws an exception if the buffer does not contain a conforming package.
If there is a package, narrows the buffer to the file's boundaries.
May narrow buffer or move point even on failure."
(goto-char (point-min))
(if (re-search-forward "^;;; \\([^ ]*\\)\\.el --- \\(.*\\)$" nil t)
(let ((file-name (match-string 1))
(desc (match-string 2))
(start (progn (beginning-of-line) (point))))
(if (search-forward (concat ";;; " file-name ".el ends here"))
(progn
;; Try to include a trailing newline.
(forward-line)
(narrow-to-region start (point))
(require 'lisp-mnt)
;; Use some headers we've invented to drive the process.
(let* ((requires-str (lm-header "package-requires"))
(requires (if requires-str
(package-read-from-string requires-str)))
;; Prefer Package-Version, because if it is
;; defined the package author probably wants us
;; to use it. Otherwise try Version.
(pkg-version
(or (package-strip-rcs-id (lm-header "package-version"))
(package-strip-rcs-id (lm-header "version"))))
(commentary (lm-commentary)))
(unless pkg-version
(error
"Package does not define a usable \"Version\" or \"Package-Version\" header"))
;; Turn string version numbers into list form.
(setq requires
(mapcar
(lambda (elt)
(list (car elt)
(package-version-split (car (cdr elt)))))
requires))
(set-text-properties 0 (length file-name) nil file-name)
(set-text-properties 0 (length pkg-version) nil pkg-version)
(set-text-properties 0 (length desc) nil desc)
(vector file-name requires desc pkg-version commentary)))
(error "Package missing a terminating comment")))
(error "No starting comment for package")))
(defun package-tar-file-info (file)
"Find package information for a tar file.
FILE is the name of the tar file to examine.
The return result is a vector like `package-buffer-info'."
(setq file (expand-file-name file))
(unless (string-match "^\\(.+\\)-\\([0-9.]+\\)\\.tar$" file)
(error "`%s' doesn't have a package-ish name" file))
(let* ((pkg-name (file-name-nondirectory (match-string-no-properties 1 file)))
(pkg-version (match-string-no-properties 2 file))
;; Extract the package descriptor.
(pkg-def-contents (shell-command-to-string
;; Requires GNU tar.
(concat "tar -xOf " file " "
pkg-name "-" pkg-version "/"
pkg-name "-pkg.el")))
(pkg-def-parsed (package-read-from-string pkg-def-contents)))
(unless (eq (car pkg-def-parsed) 'define-package)
(error "%s-pkg.el doesn't contain `define-package' sexp" pkg-name))
(let ((name-str (nth 1 pkg-def-parsed))
(version-string (nth 2 pkg-def-parsed))
(docstring (nth 3 pkg-def-parsed))
(requires (nth 4 pkg-def-parsed))
(readme (shell-command-to-string
;; Requires GNU tar.
(concat "tar -xOf " file " "
pkg-name "-" pkg-version "/README"))))
(unless (equal pkg-version version-string)
(error "Inconsistent versions!"))
(unless (equal pkg-name name-str)
(error "Inconsistent names!"))
;; Kind of a hack.
(if (string-match ": Not found in archive" readme)
(setq readme nil))
;; Turn string version numbers into list form.
(if (eq (car requires) 'quote)
(setq requires (car (cdr requires))))
(setq requires
(mapcar
(lambda (elt)
(list (car elt)
(package-version-split (car (cdr elt)))))
requires))
(vector pkg-name requires docstring version-string readme))))
(defun package-install-buffer-internal (pkg-info type)
"Download and install a single package.
PKG-INFO describes the package to be installed.
TYPE is either `single' or `tar'."
(save-excursion
(save-restriction
(let* ((file-name (aref pkg-info 0))
(requires (aref pkg-info 1))
(desc (if (string= (aref pkg-info 2) "")
"No description available."
(aref pkg-info 2)))
(pkg-version (aref pkg-info 3)))
;; Download and install the dependencies.
(let ((transaction (package-compute-transaction nil requires)))
(package-download-transaction transaction))
;; Install the package itself.
(cond
((eq type 'single)
(package-unpack-single file-name pkg-version desc requires))
((eq type 'tar)
(package-unpack (intern file-name) pkg-version))
(t
(error "Unknown type: %s" (symbol-name type))))
;; Try to activate it.
(package-initialize)))))
(defun package-install-from-buffer ()
"Install a package from the current buffer.
The package is assumed to be a single .el file which
follows the elisp comment guidelines; see
info node `(elisp)Library Headers'."
(interactive)
(package-install-buffer-internal (package-buffer-info) 'single))
(defun package-install-file (file)
"Install a package from a FILE.
The file can either be a tar file or an Emacs Lisp file."
(interactive "fPackage file name: ")
(with-temp-buffer
(insert-file-contents-literally file)
(cond
((string-match "\\.el$" file) (package-install-from-buffer))
((string-match "\\.tar$" file)
(package-install-buffer-internal (package-tar-file-info file) 'tar))
(t (error "Unrecognized extension `%s'" (file-name-extension file))))))
(defun package-delete (name version)
"Delete package NAME at VERSION."
(require 'dired) ; for dired-delete-file
(dired-delete-file (concat (file-name-as-directory package-user-dir)
name "-" version)
;; FIXME: query user?
'always))
(defun package--encode (string)
"Encode a STRING by replacing some characters with XML entities."
;; We need a special case for translating "&" to "&".
(let ((index))
(while (setq index (string-match "[&]" string index))
(setq string (replace-match "&" t nil string))
(setq index (1+ index))))
(while (string-match "[<]" string)
(setq string (replace-match "<" t nil string)))
(while (string-match "[>]" string)
(setq string (replace-match ">" t nil string)))
(while (string-match "[']" string)
(setq string (replace-match "'" t nil string)))
(while (string-match "[\"]" string)
(setq string (replace-match """ t nil string)))
string)
(defun package--update-file (file location text)
"Update FILE by finding LOCATION and inserting TEXT."
(save-excursion
(let ((old-buffer (find-buffer-visiting file)))
(with-current-buffer (let ((find-file-visit-truename t))
(or old-buffer (find-file-noselect file)))
(goto-char (point-min))
(search-forward location)
(forward-line)
(insert text)
(let ((file-precious-flag t))
(save-buffer))
(unless old-buffer
(kill-buffer (current-buffer)))))))
(defun package-archive-for (name)
"Return the archive containing the package NAME."
(let ((desc (cdr (assq (intern-soft name) package-archive-contents))))
(cdr (assoc (aref desc (- (length desc) 1)) package-archives))))
(defun package--download-one-archive (archive file)
"Download a single archive file and cache it locally.
Downloads the archive index from ARCHIVE and stores it in FILE."
(let* ((archive-name (car archive))
(archive-url (cdr archive))
(buffer (url-retrieve-synchronously (concat archive-url file))))
(save-excursion
(set-buffer buffer)
(package-handle-response)
(re-search-forward "^$" nil 'move)
(forward-char)
(delete-region (point-min) (point))
(make-directory (concat (file-name-as-directory package-user-dir)
"archives/" archive-name) t)
(setq buffer-file-name (concat (file-name-as-directory package-user-dir)
"archives/" archive-name "/" file))
(let ((version-control 'never))
(save-buffer))
(kill-buffer buffer))))
(defun package-refresh-contents ()
"Download the ELPA archive description if needed.
Invoking this will ensure that Emacs knows about the latest versions
of all packages. This will let Emacs make them available for
download."