Come installare automaticamente i pacchetti Emacs specificando un elenco di nomi di pacchetti?

Sto usando packageper gestire le mie estensioni Emacs. Per sincronizzare le mie impostazioni di Emacs su diversi computer, mi piacerebbe un modo per specificare un elenco di nomi di pacchetti nel .emacsfile e quindi packagecercare e installare automaticamente i pacchetti, in modo da non doverli installare manualmente chiamando M-x package-list-packages. Come farlo?

; list the packages you want
(setq package-list '(package1 package2))

; list the repositories containing them
(setq package-archives '(("elpa" . "http://tromey.com/elpa/")
                         ("gnu" . "http://elpa.gnu.org/packages/")
                         ("marmalade" . "http://marmalade-repo.org/packages/")))

; activate all the packages (in particular autoloads)
(package-initialize)

; fetch the list of packages available 
(unless package-archive-contents
  (package-refresh-contents))

; install the missing packages
(dolist (package package-list)
  (unless (package-installed-p package)
    (package-install package)))

Sulla base dei commenti di Profpatsch e delle risposte seguenti:

(defun ensure-package-installed (&rest packages)
  "Assure every package is installed, ask for installation if it’s not.

Return a list of installed packages or nil for every skipped package."
  (mapcar
   (lambda (package)
     ;; (package-installed-p 'evil)
     (if (package-installed-p package)
         nil
       (if (y-or-n-p (format "Package %s is missing. Install it? " package))
           (package-install package)
         package)))
   packages))

;; make sure to have downloaded archive description.
;; Or use package-archive-contents as suggested by Nicolas Dudebout
(or (file-exists-p package-user-dir)
    (package-refresh-contents))

(ensure-package-installed 'iedit 'magit) ;  --> (nil nil) if iedit and magit are already installed

;; activate installed packages
(package-initialize)

Emacs 25.1+ terrà automaticamente traccia dei pacchetti installati dall'utente nella package-selected-packagesvariabile personalizzabile . package-installaggiornerà la variabile di personalizzazione e potrai installare tutti i pacchetti selezionati con la package-install-selected-packagesfunzione.

Un altro vantaggio conveniente di questo approccio è che puoi usare package-autoremoveper rimuovere automaticamente i pacchetti che non sono inclusi in package-selected-packages(anche se preserverà le dipendenze).

(package-initialize)
(unless package-archive-contents
  (package-refresh-contents))
(package-install-selected-packages)

Fonte: http://endlessparentheses.com/new-in-package-el-in-emacs-25-1-user-selected-packages.html

Ecco il codice che uso per Emacs Prelude :

(require 'package)
(require 'melpa)
(add-to-list 'package-archives
             '("melpa" . "http://melpa.milkbox.net/packages/") t)
(package-initialize)

(setq url-http-attempt-keepalives nil)

(defvar prelude-packages
  '(ack-and-a-half auctex clojure-mode coffee-mode deft expand-region
                   gist haml-mode haskell-mode helm helm-projectile inf-ruby
                   magit magithub markdown-mode paredit projectile
                   python sass-mode rainbow-mode scss-mode solarized-theme
                   volatile-highlights yaml-mode yari yasnippet zenburn-theme)
  "A list of packages to ensure are installed at launch.")

(defun prelude-packages-installed-p ()
  (loop for p in prelude-packages
        when (not (package-installed-p p)) do (return nil)
        finally (return t)))

(unless (prelude-packages-installed-p)
  ;; check for new packages (package versions)
  (message "%s" "Emacs Prelude is now refreshing its package database...")
  (package-refresh-contents)
  (message "%s" " done.")
  ;; install the missing packages
  (dolist (p prelude-packages)
    (when (not (package-installed-p p))
      (package-install p))))

(provide 'prelude-packages)

Se non stai usando MELPA non è necessario che tu lo richieda (e se lo fai melpa.eldeve essere sul tuo load-path(o installato tramite MELPA). Il pacchetto db non viene aggiornato ogni volta (in quanto ciò rallenterebbe notevolmente l'avvio ) - solo dove sono presenti pacchetti disinstallati.

Nessuno ha menzionato Cask ancora , ma è abbastanza adatto per questo compito.

Fondamentalmente crei l' ~/.emacs.d/Caskelenco dei pacchetti che vuoi installare. Per esempio:

(source melpa)
(depends-on "expand-region")
(depends-on "goto-last-change")
; ... etc

In esecuzione cask dalla riga di comando installerà questi pacchetti per te e tutte le dipendenze di cui hanno bisogno.

Inoltre, puoi aggiornare automaticamente i pacchetti installati utilizzando cask update.

Chiama package-installcon il nome del pacchetto come simbolo. Puoi trovare i nomi dei pacchetti per i tuoi pacchetti chiamando in modo package-installinterattivo e completando il nome. La funzionepackage-installed-p ti farà sapere se è già stato installato.

Per esempio:

(mapc
 (lambda (package)
   (or (package-installed-p package)
       (package-install package)))
 '(package1 package2 package3))

(require 'cl)
(require 'package)

(setq cfg-var:packages '(
       emmet-mode
       ergoemacs-mode
       flycheck
       flycheck-pyflakes
       monokai-theme
       py-autopep8
       py-isort
       rainbow-mode
       yafolding
       yasnippet))

(defun cfg:install-packages ()
    (let ((pkgs (remove-if #'package-installed-p cfg-var:packages)))
        (when pkgs
            (message "%s" "Emacs refresh packages database...")
            (package-refresh-contents)
            (message "%s" " done.")
            (dolist (p cfg-var:packages)
                (package-install p)))))

(add-to-list 'package-archives '("gnu" . "http://elpa.gnu.org/packages/") t)
(add-to-list 'package-archives '("melpa" . "http://melpa.org/packages/") t)
(add-to-list 'package-archives '("melpa-stable" . "http://stable.melpa.org/packages/") t)
(add-to-list 'package-archives '("org" . "http://orgmode.org/elpa/") t)
(package-initialize)

(cfg:install-packages)

Mi piace controllare se l'utente desidera installare prima i pacchetti come fatto in questa risposta . Inoltre sto aggiornando il contenuto del mio pacchetto una volta prima di installare qualsiasi cosa. Non sono sicuro che questo sia il modo migliore, ma non credo che le risposte migliori lo stessero facendo per me.

(setq required-pkgs '(jedi flycheck cider clojure-mode paredit markdown-mode jsx-mode company))

(require 'cl)

(setq pkgs-to-install
      (let ((uninstalled-pkgs (remove-if 'package-installed-p required-pkgs)))
        (remove-if-not '(lambda (pkg) (y-or-n-p (format "Package %s is missing. Install it? " pkg))) uninstalled-pkgs)))

(when (> (length pkgs-to-install) 0)
  (package-refresh-contents)
  (dolist (pkg pkgs-to-install)
    (package-install pkg)))

Mi sono imbattuto in un problema che non è successo niente dopo l'aggiunta (package-install 'org)in .emacs. Volevo installare la versione aggiornata di org-modee il built-in org-modeè piuttosto vecchio.

Ho estratto il codice sorgente di package-installda Emacs 25.3.1. La funzione self controlla già se un pacchetto è installato o meno e si rifiuta di installarlo se il pacchetto è già installato. Quindi il controllo (unless (package-installed-p package) ...)dalla risposta 10093312 è in realtà non richiesto.

(defun package-install (pkg &optional dont-select)
  "Install the package PKG.
PKG can be a package-desc or a symbol naming one of the available packages
in an archive in `package-archives'.  Interactively, prompt for its name.

If called interactively or if DONT-SELECT nil, add PKG to
`package-selected-packages'.

If PKG is a package-desc and it is already installed, don't try
to install it but still mark it as selected."
  (interactive
   (progn
     ;; Initialize the package system to get the list of package
     ;; symbols for completion.
     (unless package--initialized
       (package-initialize t))
     (unless package-archive-contents
       (package-refresh-contents))
     (list (intern (completing-read
                    "Install package: "
                    (delq nil
                          (mapcar (lambda (elt)
                                    (unless (package-installed-p (car elt))
                                      (symbol-name (car elt))))
                                  package-archive-contents))
                    nil t))
           nil)))
  (add-hook 'post-command-hook #'package-menu--post-refresh)
  (let ((name (if (package-desc-p pkg)
                  (package-desc-name pkg)
                pkg)))
    (unless (or dont-select (package--user-selected-p name))
      (package--save-selected-packages
       (cons name package-selected-packages)))
    (if-let ((transaction
              (if (package-desc-p pkg)
                  (unless (package-installed-p pkg)
                    (package-compute-transaction (list pkg)
                                                 (package-desc-reqs pkg)))
                (package-compute-transaction () (list (list pkg))))))
        (package-download-transaction transaction)
      (message "`%s' is already installed" name))))

Anche il built-in org-modeconta come installato e si package-installrifiuta di installare la versione più recente da ELPA. Dopo aver passato un po 'di tempo a leggere package.el, ho trovato la seguente soluzione.

(dolist (package (package-compute-transaction
                  () (list (list 'python '(0 25 1))
                           (list 'org '(20171211)))))
  ;; package-download-transaction may be more suitable here and
  ;; I don't have time to check it
  (package-install package))

Il motivo per cui funziona è che le package-*funzioni familiari gestiscono gli argomenti in modo diverso a seconda che si tratti di un simbolo o di un package-descoggetto. È possibile specificare solo le informazioni sulla versione package-installtramite un package-descoggetto.

Ecco il mio, è più corto :)

(mapc
 (lambda (package)
   (unless (package-installed-p package)
     (progn (message "installing %s" package)
            (package-refresh-contents)
            (package-install package))))
 '(browse-kill-ring flycheck less-css-mode tabbar org auto-complete undo-tree clojure-mode markdown-mode yasnippet paredit paredit-menu php-mode haml-mode rainbow-mode fontawesome))

Ecco un altro modo.

;; assure every package is installed
(defun ensure-package-installed (&rest packages)
  (let ((user-required-packages
         (seq-remove
          (lambda (package) (package-installed-p package))
          packages)))
    (when user-required-packages
      (package-refresh-contents)
      (dolist (package user-required-packages)
        (package-install package)))))

;; list of packages to install
(ensure-package-installed
 'try
 'which-key)