diff options
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801')
20 files changed, 0 insertions, 3653 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/dir b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/dir deleted file mode 100644 index 651b05d8ef7a..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/dir +++ /dev/null @@ -1,18 +0,0 @@ -This is the file .../info/dir, which contains the -topmost node of the Info hierarchy, called (dir)Top. -The first time you invoke Info you start off looking at this node. - -File: dir, Node: Top This is the top of the INFO tree - - This (the Directory node) gives a menu of major topics. - Typing "q" exits, "H" lists all Info commands, "d" returns here, - "h" gives a primer for first-timers, - "mEmacs<Return>" visits the Emacs manual, etc. - - In Emacs, you can click mouse button 2 on a menu item or cross reference - to select it. - -* Menu: - -Emacs -* use-package: (use-package). Declarative package configuration for Emacs. diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-autoloads.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-autoloads.el deleted file mode 100644 index e205039668e5..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-autoloads.el +++ /dev/null @@ -1,209 +0,0 @@ -;;; use-package-autoloads.el --- automatically extracted autoloads -;; -;;; Code: -(add-to-list 'load-path (directory-file-name (or (file-name-directory #$) (car load-path)))) - -;;;### (autoloads nil "use-package-bind-key" "use-package-bind-key.el" -;;;;;; (23450 31796 849165 290000)) -;;; Generated autoloads from use-package-bind-key.el - -(autoload 'use-package-autoload-keymap "use-package-bind-key" "\ -Loads PACKAGE and then binds the key sequence used to invoke -this function to KEYMAP-SYMBOL. It then simulates pressing the -same key sequence a again, so that the next key pressed is routed -to the newly loaded keymap. - -This function supports use-package's :bind-keymap keyword. It -works by binding the given key sequence to an invocation of this -function for a particular keymap. The keymap is expected to be -defined by the package. In this way, loading the package is -deferred until the prefix key sequence is pressed. - -\(fn KEYMAP-SYMBOL PACKAGE OVERRIDE)" nil nil) - -(autoload 'use-package-normalize-binder "use-package-bind-key" "\ - - -\(fn NAME KEYWORD ARGS)" nil nil) - -(defalias 'use-package-normalize/:bind 'use-package-normalize-binder) - -(defalias 'use-package-normalize/:bind* 'use-package-normalize-binder) - -(defalias 'use-package-autoloads/:bind 'use-package-autoloads-mode) - -(defalias 'use-package-autoloads/:bind* 'use-package-autoloads-mode) - -(autoload 'use-package-handler/:bind "use-package-bind-key" "\ - - -\(fn NAME KEYWORD ARGS REST STATE &optional BIND-MACRO)" nil nil) - -(defalias 'use-package-normalize/:bind-keymap 'use-package-normalize-binder) - -(defalias 'use-package-normalize/:bind-keymap* 'use-package-normalize-binder) - -(autoload 'use-package-handler/:bind-keymap "use-package-bind-key" "\ - - -\(fn NAME KEYWORD ARGS REST STATE &optional OVERRIDE)" nil nil) - -(autoload 'use-package-handler/:bind-keymap* "use-package-bind-key" "\ - - -\(fn NAME KEYWORD ARG REST STATE)" nil nil) - -;;;*** - -;;;### (autoloads nil "use-package-core" "use-package-core.el" (23450 -;;;;;; 31796 836232 317000)) -;;; Generated autoloads from use-package-core.el - -(autoload 'use-package "use-package-core" "\ -Declare an Emacs package by specifying a group of configuration options. - -For full documentation, please see the README file that came with -this file. Usage: - - (use-package package-name - [:keyword [option]]...) - -:init Code to run before PACKAGE-NAME has been loaded. -:config Code to run after PACKAGE-NAME has been loaded. Note that - if loading is deferred for any reason, this code does not - execute until the lazy load has occurred. -:preface Code to be run before everything except `:disabled'; this - can be used to define functions for use in `:if', or that - should be seen by the byte-compiler. - -:mode Form to be added to `auto-mode-alist'. -:magic Form to be added to `magic-mode-alist'. -:magic-fallback Form to be added to `magic-fallback-mode-alist'. -:interpreter Form to be added to `interpreter-mode-alist'. - -:commands Define autoloads for commands that will be defined by the - package. This is useful if the package is being lazily - loaded, and you wish to conditionally call functions in your - `:init' block that are defined in the package. - -:bind Bind keys, and define autoloads for the bound commands. -:bind* Bind keys, and define autoloads for the bound commands, - *overriding all minor mode bindings*. -:bind-keymap Bind a key prefix to an auto-loaded keymap defined in the - package. This is like `:bind', but for keymaps. -:bind-keymap* Like `:bind-keymap', but overrides all minor mode bindings - -:defer Defer loading of a package -- this is implied when using - `:commands', `:bind', `:bind*', `:mode', `:magic', - `:magic-fallback', or `:interpreter'. This can be an integer, - to force loading after N seconds of idle time, if the package - has not already been loaded. -:after Defer loading of a package until after any of the named - features are loaded. -:demand Prevent deferred loading in all cases. - -:if EXPR Initialize and load only if EXPR evaluates to a non-nil value. -:disabled The package is ignored completely if this keyword is present. -:defines Declare certain variables to silence the byte-compiler. -:functions Declare certain functions to silence the byte-compiler. -:load-path Add to the `load-path' before attempting to load the package. -:diminish Support for diminish.el (if installed). -:delight Support for delight.el (if installed). -:custom Call `customize-set-variable' with each variable definition. -:custom-face Call `customize-set-faces' with each face definition. -:ensure Loads the package using package.el if necessary. -:pin Pin the package to an archive. - -\(fn NAME &rest ARGS)" nil t) - -(function-put 'use-package 'lisp-indent-function '1) - -;;;*** - -;;;### (autoloads nil "use-package-delight" "use-package-delight.el" -;;;;;; (23450 31796 832995 790000)) -;;; Generated autoloads from use-package-delight.el - -(autoload 'use-package-normalize/:delight "use-package-delight" "\ -Normalize arguments to delight. - -\(fn NAME KEYWORD ARGS)" nil nil) - -(autoload 'use-package-handler/:delight "use-package-delight" "\ - - -\(fn NAME KEYWORD ARGS REST STATE)" nil nil) - -;;;*** - -;;;### (autoloads nil "use-package-diminish" "use-package-diminish.el" -;;;;;; (23450 31796 844304 563000)) -;;; Generated autoloads from use-package-diminish.el - -(autoload 'use-package-normalize/:diminish "use-package-diminish" "\ - - -\(fn NAME KEYWORD ARGS)" nil nil) - -(autoload 'use-package-handler/:diminish "use-package-diminish" "\ - - -\(fn NAME KEYWORD ARG REST STATE)" nil nil) - -;;;*** - -;;;### (autoloads nil "use-package-ensure" "use-package-ensure.el" -;;;;;; (23450 31796 837874 464000)) -;;; Generated autoloads from use-package-ensure.el - -(autoload 'use-package-normalize/:ensure "use-package-ensure" "\ - - -\(fn NAME KEYWORD ARGS)" nil nil) - -(autoload 'use-package-handler/:ensure "use-package-ensure" "\ - - -\(fn NAME KEYWORD ENSURE REST STATE)" nil nil) - -;;;*** - -;;;### (autoloads nil "use-package-jump" "use-package-jump.el" (23450 -;;;;;; 31796 839462 558000)) -;;; Generated autoloads from use-package-jump.el - -(autoload 'use-package-jump-to-package-form "use-package-jump" "\ -Attempt to find and jump to the `use-package' form that loaded -PACKAGE. This will only find the form if that form actually -required PACKAGE. If PACKAGE was previously required then this -function will jump to the file that originally required PACKAGE -instead. - -\(fn PACKAGE)" t nil) - -;;;*** - -;;;### (autoloads nil "use-package-lint" "use-package-lint.el" (23450 -;;;;;; 31796 842433 562000)) -;;; Generated autoloads from use-package-lint.el - -(autoload 'use-package-lint "use-package-lint" "\ -Check for errors in use-package declarations. -For example, if the module's `:if' condition is met, but even -with the specified `:load-path' the module cannot be found. - -\(fn)" t nil) - -;;;*** - -;;;### (autoloads nil nil ("use-package-pkg.el" "use-package.el") -;;;;;; (23450 31796 840978 222000)) - -;;;*** - -;; Local Variables: -;; version-control: never -;; no-byte-compile: t -;; no-update-autoloads: t -;; End: -;;; use-package-autoloads.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-bind-key.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-bind-key.el deleted file mode 100644 index e476b060ad6c..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-bind-key.el +++ /dev/null @@ -1,172 +0,0 @@ -;;; use-package-bind-key.el --- Support for the :bind/:bind-keymap keywords -*- lexical-binding: t; -*- - -;; Copyright (C) 2012-2017 John Wiegley - -;; Author: John Wiegley <johnw@newartisans.com> -;; Maintainer: John Wiegley <johnw@newartisans.com> -;; Created: 17 Jun 2012 -;; Modified: 4 Dec 2017 -;; Version: 1.0 -;; Package-Requires: ((emacs "24.3") (use-package "2.4") (bind-key "2.4")) -;; Keywords: dotemacs startup speed config package -;; URL: https://github.com/jwiegley/use-package - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the GNU General Public License as -;; published by the Free Software Foundation; either version 3, 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: - -;; Provides support for the :bind, :bind*, :bind-keymap and :bind-keymap* -;; keywords. Note that these are currently still baked into -;; `use-package-keywords' and `use-package-deferring-keywords', although this -;; is harmless if they are never used. - -;;; Code: - -(require 'use-package-core) -(require 'bind-key) - -;;;###autoload -(defun use-package-autoload-keymap (keymap-symbol package override) - "Loads PACKAGE and then binds the key sequence used to invoke -this function to KEYMAP-SYMBOL. It then simulates pressing the -same key sequence a again, so that the next key pressed is routed -to the newly loaded keymap. - -This function supports use-package's :bind-keymap keyword. It -works by binding the given key sequence to an invocation of this -function for a particular keymap. The keymap is expected to be -defined by the package. In this way, loading the package is -deferred until the prefix key sequence is pressed." - (if (not (require package nil t)) - (use-package-error (format "Cannot load package.el: %s" package)) - (if (and (boundp keymap-symbol) - (keymapp (symbol-value keymap-symbol))) - (let* ((kv (this-command-keys-vector)) - (key (key-description kv)) - (keymap (symbol-value keymap-symbol))) - (if override - (bind-key* key keymap) - (bind-key key keymap)) - (setq unread-command-events - (mapcar (lambda (ev) (cons t ev)) - (listify-key-sequence kv)))) - (use-package-error - (format "package.el %s failed to define keymap %s" - package keymap-symbol))))) - -;;;###autoload -(defun use-package-normalize-binder (name keyword args) - (let ((arg args) - args*) - (while arg - (let ((x (car arg))) - (cond - ;; (KEY . COMMAND) - ((and (consp x) - (or (stringp (car x)) - (vectorp (car x))) - (or (use-package-recognize-function (cdr x) t #'stringp))) - (setq args* (nconc args* (list x))) - (setq arg (cdr arg))) - ;; KEYWORD - ;; :map KEYMAP - ;; :prefix-docstring STRING - ;; :prefix-map SYMBOL - ;; :prefix STRING - ;; :filter SEXP - ;; :menu-name STRING - ;; :package SYMBOL - ((or (and (eq x :map) (symbolp (cadr arg))) - (and (eq x :prefix) (stringp (cadr arg))) - (and (eq x :prefix-map) (symbolp (cadr arg))) - (and (eq x :prefix-docstring) (stringp (cadr arg))) - (eq x :filter) - (and (eq x :menu-name) (stringp (cadr arg))) - (and (eq x :package) (symbolp (cadr arg)))) - (setq args* (nconc args* (list x (cadr arg)))) - (setq arg (cddr arg))) - ((listp x) - (setq args* - (nconc args* (use-package-normalize-binder name keyword x))) - (setq arg (cdr arg))) - (t - ;; Error! - (use-package-error - (concat (symbol-name name) - " wants arguments acceptable to the `bind-keys' macro," - " or a list of such values")))))) - args*)) - -;;;; :bind, :bind* - -;;;###autoload -(defalias 'use-package-normalize/:bind 'use-package-normalize-binder) -;;;###autoload -(defalias 'use-package-normalize/:bind* 'use-package-normalize-binder) - -;; jww (2017-12-07): This is too simplistic. It will fail to determine -;; autoloads in this situation: -;; (use-package foo -;; :bind (:map foo-map (("C-a" . func)))) -;;;###autoload -(defalias 'use-package-autoloads/:bind 'use-package-autoloads-mode) -;;;###autoload -(defalias 'use-package-autoloads/:bind* 'use-package-autoloads-mode) - -;;;###autoload -(defun use-package-handler/:bind - (name _keyword args rest state &optional bind-macro) - (use-package-concat - (use-package-process-keywords name rest state) - `(,@(mapcar - #'(lambda (xs) - `(,(if bind-macro bind-macro 'bind-keys) - :package ,name ,@(use-package-normalize-commands xs))) - (use-package-split-list-at-keys :break args))))) - -(defun use-package-handler/:bind* (name keyword arg rest state) - (use-package-handler/:bind name keyword arg rest state 'bind-keys*)) - -;;;; :bind-keymap, :bind-keymap* - -;;;###autoload -(defalias 'use-package-normalize/:bind-keymap 'use-package-normalize-binder) -;;;###autoload -(defalias 'use-package-normalize/:bind-keymap* 'use-package-normalize-binder) - -;;;###autoload -(defun use-package-handler/:bind-keymap - (name _keyword args rest state &optional override) - (use-package-concat - (use-package-process-keywords name rest state) - (mapcar - #'(lambda (binding) - `(,(if override 'bind-key* 'bind-key) - ,(car binding) - #'(lambda () - (interactive) - (use-package-autoload-keymap - ',(cdr binding) ',(use-package-as-symbol name) - ,override)))) - args))) - -;;;###autoload -(defun use-package-handler/:bind-keymap* (name keyword arg rest state) - (use-package-handler/:bind-keymap name keyword arg rest state t)) - -(provide 'use-package-bind-key) - -;;; use-package-bind-key.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-bind-key.elc b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-bind-key.elc deleted file mode 100644 index dae7a16c6690..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-bind-key.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-core.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-core.el deleted file mode 100644 index 525b478313bf..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-core.el +++ /dev/null @@ -1,1591 +0,0 @@ -;;; use-package-core.el --- A configuration macro for simplifying your .emacs -*- lexical-binding: t; -*- - -;; Copyright (C) 2012-2017 John Wiegley - -;; Author: John Wiegley <johnw@newartisans.com> -;; Maintainer: John Wiegley <johnw@newartisans.com> -;; Created: 17 Jun 2012 -;; Modified: 29 Nov 2017 -;; Version: 2.4 -;; Package-Requires: ((emacs "24.3")) -;; Keywords: dotemacs startup speed config package -;; URL: https://github.com/jwiegley/use-package - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the GNU General Public License as -;; published by the Free Software Foundation; either version 3, 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: - -;; The `use-package' declaration macro allows you to isolate package -;; configuration in your ".emacs" in a way that is performance-oriented and, -;; well, just tidy. I created it because I have over 80 packages that I use -;; in Emacs, and things were getting difficult to manage. Yet with this -;; utility my total load time is just under 1 second, with no loss of -;; functionality! -;; -;; Please see README.md from the same repository for documentation. - -;;; Code: - -(require 'bytecomp) -(require 'cl-lib) -(require 'tabulated-list) - -(if (and (eq emacs-major-version 24) (eq emacs-minor-version 3)) - (defsubst hash-table-keys (hash-table) - "Return a list of keys in HASH-TABLE." - (cl-loop for k being the hash-keys of hash-table collect k)) - (eval-when-compile (require 'subr-x))) - -(eval-when-compile - (require 'regexp-opt)) - -(defgroup use-package nil - "A use-package declaration for simplifying your `.emacs'." - :group 'startup) - -(defconst use-package-version "2.4" - "This version of use-package.") - -(defcustom use-package-keywords - '(:disabled - :load-path - :requires - :defines - :functions - :preface - :if :when :unless - :no-require - :catch - :after - :custom - :custom-face - :bind - :bind* - :bind-keymap - :bind-keymap* - :interpreter - :mode - :magic - :magic-fallback - :hook - ;; Any other keyword that also declares commands to be autoloaded (such as - ;; :bind) must appear before this keyword. - :commands - :init - :defer - :demand - :load - ;; This must occur almost last; the only forms which should appear after - ;; are those that must happen directly after the config forms. - :config) - "The set of valid keywords, in the order they are processed in. -The order of this list is *very important*, so it is only -advisable to insert new keywords, never to delete or reorder -them. Further, attention should be paid to the NEWS.md if the -default order ever changes, as they may have subtle effects on -the semantics of use-package declarations and may necessitate -changing where you had inserted a new keyword earlier. - -Note that `:disabled' is special in this list, as it causes -nothing at all to happen, even if the rest of the use-package -declaration is incorrect." - :type '(repeat symbol) - :group 'use-package) - -(defcustom use-package-deferring-keywords - '(:bind-keymap - :bind-keymap* - :commands) - "Unless `:demand' is used, keywords in this list imply deferred loading. -The reason keywords like `:hook' are not in this list is that -they only imply deferred loading if they reference actual -function symbols that can be autoloaded from the module; whereas -the default keywords provided here always defer loading unless -otherwise requested." - :type '(repeat symbol) - :group 'use-package) - -(defcustom use-package-ignore-unknown-keywords nil - "If non-nil, issue warning instead of error when unknown -keyword is encountered. The unknown keyword and its associated -arguments will be ignored in the `use-package' expansion." - :type 'boolean - :group 'use-package) - -(defcustom use-package-verbose nil - "Whether to report about loading and configuration details. -If you customize this, then you should require the `use-package' -feature in files that use `use-package', even if these files only -contain compiled expansions of the macros. If you don't do so, -then the expanded macros do their job silently." - :type '(choice (const :tag "Quiet, without catching errors" errors) - (const :tag "Quiet" nil) - (const :tag "Verbose" t) - (const :tag "Debug" debug)) - :group 'use-package) - -(defcustom use-package-check-before-init nil - "If non-nil, check that package exists before executing its `:init' block. -This check is performed by calling `locate-library'." - :type 'boolean - :group 'use-package) - -(defcustom use-package-always-defer nil - "If non-nil, assume `:defer t' unless `:demand' is used. -See also `use-package-defaults', which uses this value." - :type 'boolean - :group 'use-package) - -(defcustom use-package-always-demand nil - "If non-nil, assume `:demand t' unless `:defer' is used. -See also `use-package-defaults', which uses this value." - :type 'boolean - :group 'use-package) - -(defcustom use-package-defaults - '(;; this '(t) has special meaning; see `use-package-handler/:config' - (:config '(t) t) - (:init nil t) - (:catch t (lambda (name args) - (not use-package-expand-minimally))) - (:defer use-package-always-defer - (lambda (name args) - (and use-package-always-defer - (not (plist-member args :defer)) - (not (plist-member args :demand))))) - (:demand use-package-always-demand - (lambda (name args) - (and use-package-always-demand - (not (plist-member args :defer)) - (not (plist-member args :demand)))))) - "Default values for specified `use-package' keywords. -Each entry in the alist is a list of three elements: -The first element is the `use-package' keyword. - -The second is a form that can be evaluated to get the default -value. It can also be a function that will receive the name of -the use-package declaration and the keyword plist given to -`use-package', in normalized form. The value it returns should -also be in normalized form (which is sometimes *not* what one -would normally write in a `use-package' declaration, so use -caution). - -The third element is a form that can be evaluated to determine -whether or not to assign a default value; if it evaluates to nil, -then the default value is not assigned even if the keyword is not -present in the `use-package' form. This third element may also be -a function, in which case it receives the name of the package (as -a symbol) and a list of keywords (in normalized form). It should -return nil or non-nil depending on whether defaulting should be -attempted." - :type `(repeat - (list (choice :tag "Keyword" - ,@(mapcar #'(lambda (k) (list 'const k)) - use-package-keywords)) - (choice :tag "Default value" sexp function) - (choice :tag "Enable if non-nil" sexp function))) - :group 'use-package) - -(defcustom use-package-merge-key-alist - '((:if . (lambda (new old) `(and ,new ,old))) - (:after . (lambda (new old) `(:all ,new ,old))) - (:defer . (lambda (new old) old)) - (:bind . (lambda (new old) (append new (list :break) old)))) - "Alist of keys and the functions used to merge multiple values. -For example, if the following form is provided: - - (use-package foo :if pred1 :if pred2) - -Then based on the above defaults, the merged result will be: - - (use-package foo :if (and pred1 pred2)) - -This is done so that, at the stage of invoking handlers, each -handler is called only once." - :type `(repeat - (cons (choice :tag "Keyword" - ,@(mapcar #'(lambda (k) (list 'const k)) - use-package-keywords) - (const :tag "Any" t)) - function)) - :group 'use-package) - -(defcustom use-package-hook-name-suffix "-hook" - "Text append to the name of hooks mentioned by :hook. -Set to nil if you don't want this to happen; it's only a -convenience." - :type '(choice string (const :tag "No suffix" nil)) - :group 'use-package) - -(defcustom use-package-minimum-reported-time 0.1 - "Minimal load time that will be reported. -Note that `use-package-verbose' has to be set to a non-nil value -for anything to be reported at all." - :type 'number - :group 'use-package) - -(defcustom use-package-inject-hooks nil - "If non-nil, add hooks to the `:init' and `:config' sections. -In particular, for a given package `foo', the following hooks -become available: - - `use-package--foo--pre-init-hook' - `use-package--foo--post-init-hook' - `use-package--foo--pre-config-hook' - `use-package--foo--post-config-hook' - -This way, you can add to these hooks before evaluation of a -`use-package` declaration, and exercise some control over what -happens. - -NOTE: These hooks are run even if the user does not specify an -`:init' or `:config' block, and they will happen at the regular -time when initialization and configuration would have been -performed. - -NOTE: If the `pre-init' hook return a nil value, that block's -user-supplied configuration is not evaluated, so be certain to -return t if you only wish to add behavior to what the user had -specified." - :type 'boolean - :group 'use-package) - -(defcustom use-package-expand-minimally nil - "If non-nil, make the expanded code as minimal as possible. -This disables: - - - Printing to the *Messages* buffer of slowly-evaluating forms - - Capturing of load errors (normally redisplayed as warnings) - - Conditional loading of packages (load failures become errors) - -The main advantage to this variable is that, if you know your -configuration works, it will make the byte-compiled file as -minimal as possible. It can also help with reading macro-expanded -definitions, to understand the main intent of what's happening." - :type 'boolean - :group 'use-package) - -(defcustom use-package-form-regexp-eval - `(concat ,(eval-when-compile - (concat "^\\s-*(" - (regexp-opt '("use-package" "require") t) - "\\s-+\\(")) - (or (bound-and-true-p lisp-mode-symbol-regexp) - "\\(?:\\sw\\|\\s_\\|\\\\.\\)+") "\\)") - "Sexp providing regexp for finding use-package forms in user files. -This is used by `use-package-jump-to-package-form' and -`use-package-enable-imenu-support'." - :type 'sexp - :group 'use-package) - -(defcustom use-package-enable-imenu-support nil - "If non-nil, cause imenu to see `use-package' declarations. -This is done by adjusting `lisp-imenu-generic-expression' to -include support for finding `use-package' and `require' forms. - -Must be set before loading use-package." - :type 'boolean - :set - #'(lambda (_sym value) - (eval-after-load 'lisp-mode - (if value - `(add-to-list 'lisp-imenu-generic-expression - (list "Packages" ,use-package-form-regexp-eval 2)) - `(setq lisp-imenu-generic-expression - (remove (list "Packages" ,use-package-form-regexp-eval 2) - lisp-imenu-generic-expression))))) - :group 'use-package) - -(defconst use-package-font-lock-keywords - '(("(\\(use-package\\)\\_>[ \t']*\\(\\(?:\\sw\\|\\s_\\)+\\)?" - (1 font-lock-keyword-face) - (2 font-lock-constant-face nil t)))) - -(font-lock-add-keywords 'emacs-lisp-mode use-package-font-lock-keywords) - -(defcustom use-package-compute-statistics nil - "If non-nil, compute statistics concerned use-package declarations. -View the statistical report using `use-package-report'. Note that -if this option is enabled, you must require `use-package' in your -user init file at loadup time, or you will see errors concerning -undefined variables." - :type 'boolean - :group 'use-package) - -(defvar use-package-statistics (make-hash-table)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; -;;; Utility functions -;; - -(defsubst use-package-error (msg) - "Report MSG as an error, so the user knows it came from this package." - (error "use-package: %s" msg)) - -(defsubst use-package-concat (&rest elems) - "Delete all empty lists from ELEMS (nil or (list nil)), and append them." - (apply #'append (delete nil (delete (list nil) elems)))) - -(defsubst use-package-non-nil-symbolp (sym) - (and sym (symbolp sym))) - -(defsubst use-package-as-symbol (string-or-symbol) - "If STRING-OR-SYMBOL is already a symbol, return it. Otherwise -convert it to a symbol and return that." - (if (symbolp string-or-symbol) string-or-symbol - (intern string-or-symbol))) - -(defsubst use-package-as-string (string-or-symbol) - "If STRING-OR-SYMBOL is already a string, return it. Otherwise -convert it to a string and return that." - (if (stringp string-or-symbol) string-or-symbol - (symbol-name string-or-symbol))) - -(defsubst use-package-regex-p (re) - "Return t if RE is some regexp-like thing." - (or (and (listp re) (eq (car re) 'rx)) - (stringp re))) - -(defun use-package-normalize-regex (re) - "Given some regexp-like thing in RE, resolve to a regular expression." - (cond - ((and (listp re) (eq (car re) 'rx)) (eval re)) - ((stringp re) re) - (t (error "Not recognized as regular expression: %s" re)))) - -(defsubst use-package-is-pair (x car-pred cdr-pred) - "Return non-nil if X is a cons satisfying the given predicates. -CAR-PRED and CDR-PRED are applied to X's `car' and `cdr', -respectively." - (and (consp x) - (funcall car-pred (car x)) - (funcall cdr-pred (cdr x)))) - -(defun use-package-as-mode (string-or-symbol) - "If STRING-OR-SYMBOL ends in `-mode' (or its name does), return -it as a symbol. Otherwise, return it as a symbol with `-mode' -appended." - (let ((string (use-package-as-string string-or-symbol))) - (intern (if (string-match "-mode\\'" string) - string - (concat string "-mode"))))) - -(defsubst use-package-load-name (name &optional noerror) - "Return a form which will load or require NAME. -It does the right thing no matter if NAME is a string or symbol. -Argument NOERROR means to indicate load failures as a warning." - (if (stringp name) - `(load ,name ,noerror) - `(require ',name nil ,noerror))) - -(defun use-package-hook-injector (name-string keyword body) - "Wrap pre/post hook injections around the given BODY for KEYWORD. -The BODY is a list of forms, so `((foo))' if only `foo' is being called." - (if (not use-package-inject-hooks) - body - (let ((keyword-name (substring (format "%s" keyword) 1))) - `((when (run-hook-with-args-until-failure - ',(intern (concat "use-package--" name-string - "--pre-" keyword-name "-hook"))) - ,@body - (run-hooks - ',(intern (concat "use-package--" name-string - "--post-" keyword-name "-hook")))))))) - -(defun use-package-with-elapsed-timer (text body) - "BODY is a list of forms, so `((foo))' if only `foo' is being called." - (declare (indent 1)) - (if use-package-expand-minimally - body - (let ((nowvar (make-symbol "now"))) - (if (bound-and-true-p use-package-verbose) - `((let ((,nowvar (current-time))) - (message "%s..." ,text) - (prog1 - ,(macroexp-progn body) - (let ((elapsed - (float-time (time-subtract (current-time) ,nowvar)))) - (if (> elapsed ,use-package-minimum-reported-time) - (message "%s...done (%.3fs)" ,text elapsed) - (message "%s...done" ,text)))))) - body)))) - -(put 'use-package-with-elapsed-timer 'lisp-indent-function 1) - -(defun use-package-require (name &optional no-require body) - (if use-package-expand-minimally - (use-package-concat - (unless no-require - (list (use-package-load-name name))) - body) - (if no-require - body - (use-package-with-elapsed-timer - (format "Loading package %s" name) - `((if (not ,(use-package-load-name name t)) - (display-warning 'use-package - (format "Cannot load %s" ',name) - :error) - ,@body)))))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; -;;; Property lists -;; - -(defun use-package-plist-delete (plist property) - "Delete PROPERTY from PLIST. -This is in contrast to merely setting it to 0." - (let (p) - (while plist - (if (not (eq property (car plist))) - (setq p (plist-put p (car plist) (nth 1 plist)))) - (setq plist (cddr plist))) - p)) - -(defun use-package-plist-delete-first (plist property) - "Delete PROPERTY from PLIST. -This is in contrast to merely setting it to 0." - (let (p) - (while plist - (if (eq property (car plist)) - (setq p (nconc p (cddr plist)) - plist nil) - (setq p (nconc p (list (car plist) (cadr plist))) - plist (cddr plist)))) - p)) - -(defsubst use-package-plist-maybe-put (plist property value) - "Add a VALUE for PROPERTY to PLIST, if it does not already exist." - (if (plist-member plist property) - plist - (plist-put plist property value))) - -(defsubst use-package-plist-cons (plist property value) - "Cons VALUE onto the head of the list at PROPERTY in PLIST." - (plist-put plist property (cons value (plist-get plist property)))) - -(defsubst use-package-plist-append (plist property value) - "Append VALUE onto the front of the list at PROPERTY in PLIST." - (plist-put plist property (append value (plist-get plist property)))) - -(defun use-package-split-list (pred xs) - (let ((ys (list nil)) (zs (list nil)) flip) - (cl-dolist (x xs) - (if flip - (nconc zs (list x)) - (if (funcall pred x) - (progn - (setq flip t) - (nconc zs (list x))) - (nconc ys (list x))))) - (cons (cdr ys) (cdr zs)))) - -(defun use-package-split-list-at-keys (key lst) - (and lst - (let ((xs (use-package-split-list (apply-partially #'eq key) lst))) - (cons (car xs) (use-package-split-list-at-keys key (cddr xs)))))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; -;;; Keywords -;; - -(defun use-package-keyword-index (keyword) - (cl-loop named outer - with index = 0 - for k in use-package-keywords do - (if (eq k keyword) - (cl-return-from outer index)) - (cl-incf index))) - -(defun use-package-normalize-plist (name input &optional plist merge-function) - "Given a pseudo-plist, normalize it to a regular plist. -The normalized key/value pairs from input are added to PLIST, -extending any keys already present." - (if (null input) - plist - (let* ((keyword (car input)) - (xs (use-package-split-list #'keywordp (cdr input))) - (args (car xs)) - (tail (cdr xs)) - (normalizer - (intern-soft (concat "use-package-normalize/" - (symbol-name keyword)))) - (arg (and (functionp normalizer) - (funcall normalizer name keyword args))) - (error-string (format "Unrecognized keyword: %s" keyword))) - (if (memq keyword use-package-keywords) - (progn - (setq plist (use-package-normalize-plist - name tail plist merge-function)) - (plist-put plist keyword - (if (plist-member plist keyword) - (funcall merge-function keyword arg - (plist-get plist keyword)) - arg))) - (if use-package-ignore-unknown-keywords - (progn - (display-warning 'use-package error-string) - (use-package-normalize-plist - name tail plist merge-function)) - (use-package-error error-string)))))) - -(defun use-package-unalias-keywords (_name args) - (setq args (cl-nsubstitute :if :when args)) - (let (temp) - (while (setq temp (plist-get args :unless)) - (setq args (use-package-plist-delete-first args :unless) - args (append args `(:if (not ,temp)))))) - args) - -(defun use-package-merge-keys (key new old) - (let ((merger (assq key use-package-merge-key-alist))) - (if merger - (funcall (cdr merger) new old) - (append new old)))) - -(defun use-package-sort-keywords (plist) - (let (plist-grouped) - (while plist - (push (cons (car plist) (cadr plist)) - plist-grouped) - (setq plist (cddr plist))) - (let (result) - (cl-dolist - (x - (nreverse - (sort plist-grouped - #'(lambda (l r) (< (use-package-keyword-index (car l)) - (use-package-keyword-index (car r))))))) - (setq result (cons (car x) (cons (cdr x) result)))) - result))) - -(defun use-package-normalize-keywords (name args) - (let* ((name-symbol (if (stringp name) (intern name) name)) - (name-string (symbol-name name-symbol))) - - ;; The function `elisp--local-variables' inserts this unbound variable into - ;; macro forms to determine the locally bound variables for - ;; `elisp-completion-at-point'. It ends up throwing a lot of errors since it - ;; can occupy the position of a keyword (or look like a second argument to a - ;; keyword that takes one). Deleting it when it's at the top level should be - ;; harmless since there should be no locally bound variables to discover - ;; here anyway. - (setq args (delq 'elisp--witness--lisp args)) - - ;; Reduce the set of keywords down to its most fundamental expression. - (setq args (use-package-unalias-keywords name-symbol args)) - - ;; Normalize keyword values, coalescing multiple occurrences. - (setq args (use-package-normalize-plist name-symbol args nil - #'use-package-merge-keys)) - - ;; Add default values for keywords not specified, when applicable. - (cl-dolist (spec use-package-defaults) - (when (let ((func (nth 2 spec))) - (if (and func (functionp func)) - (funcall func name args) - (eval func))) - (setq args (use-package-plist-maybe-put - args (nth 0 spec) - (let ((func (nth 1 spec))) - (if (and func (functionp func)) - (funcall func name args) - (eval func))))))) - - ;; Determine any autoloads implied by the keywords used. - (let ((iargs args) - commands) - (while iargs - (when (keywordp (car iargs)) - (let ((autoloads - (intern-soft (concat "use-package-autoloads/" - (symbol-name (car iargs)))))) - (when (functionp autoloads) - (setq commands - ;; jww (2017-12-07): Right now we just ignored the type of - ;; the autoload being requested, and assume they are all - ;; `command'. - (append (mapcar - #'car - (funcall autoloads name-symbol (car iargs) - (cadr iargs))) - commands))))) - (setq iargs (cddr iargs))) - (when commands - (setq args - ;; Like `use-package-plist-append', but removing duplicates. - (plist-put args :commands - (delete-dups - (append commands (plist-get args :commands))))))) - - ;; If byte-compiling, pre-load the package so all its symbols are in - ;; scope. This is done by prepending statements to the :preface. - (when (bound-and-true-p byte-compile-current-file) - (setq args - (use-package-plist-append - args :preface - (use-package-concat - (mapcar #'(lambda (var) `(defvar ,var)) - (plist-get args :defines)) - (mapcar #'(lambda (fn) `(declare-function ,fn ,name-string)) - (plist-get args :functions)) - `((eval-when-compile - (with-demoted-errors - ,(format "Cannot load %s: %%S" name-string) - ,(when (eq use-package-verbose 'debug) - `(message ,(format "Compiling package %s" name-string))) - ,(unless (plist-get args :no-require) - `(load ,name-string nil t))))))))) - - ;; Certain keywords imply :defer, if :demand was not specified. - (when (and (not (plist-member args :demand)) - (not (plist-member args :defer)) - (not (or (equal '(t) (plist-get args :load)) - (equal (list (use-package-as-string name)) - (mapcar #'use-package-as-string - (plist-get args :load))))) - (cl-some #'identity - (mapcar (apply-partially #'plist-member args) - use-package-deferring-keywords))) - (setq args (append args '(:defer t)))) - - ;; The :load keyword overrides :no-require - (when (and (plist-member args :load) - (plist-member args :no-require)) - (setq args (use-package-plist-delete args :no-require))) - - ;; If at this point no :load, :defer or :no-require has been seen, then - ;; :load the package itself. - (when (and (not (plist-member args :load)) - (not (plist-member args :defer)) - (not (plist-member args :no-require))) - (setq args (append args `(:load (,name))))) - - ;; Sort the list of keywords based on the order of `use-package-keywords'. - (use-package-sort-keywords args))) - -(defun use-package-process-keywords (name plist &optional state) - "Process the next keyword in the free-form property list PLIST. -The values in the PLIST have each been normalized by the function -use-package-normalize/KEYWORD (minus the colon). - -STATE is a property list that the function may modify and/or -query. This is useful if a package defines multiple keywords and -wishes them to have some kind of stateful interaction. - -Unless the KEYWORD being processed intends to ignore remaining -keywords, it must call this function recursively, passing in the -plist with its keyword and argument removed, and passing in the -next value for the STATE." - (declare (indent 1)) - (unless (null plist) - (let* ((keyword (car plist)) - (arg (cadr plist)) - (rest (cddr plist))) - (unless (keywordp keyword) - (use-package-error (format "%s is not a keyword" keyword))) - (let* ((handler (concat "use-package-handler/" (symbol-name keyword))) - (handler-sym (intern handler))) - (if (functionp handler-sym) - (funcall handler-sym name keyword arg rest state) - (use-package-error - (format "Keyword handler not defined: %s" handler))))))) - -(put 'use-package-process-keywords 'lisp-indent-function 'defun) - -(defun use-package-list-insert (elem xs &optional anchor after test) - "Insert ELEM into the list XS. -If ANCHOR is also a keyword, place the new KEYWORD before that -one. -If AFTER is non-nil, insert KEYWORD either at the end of the -keywords list, or after the ANCHOR if one has been provided. -If TEST is non-nil, it is the test used to compare ELEM to list -elements. The default is `eq'. -The modified list is returned. The original list is not modified." - (let (result) - (dolist (k xs) - (if (funcall (or test #'eq) k anchor) - (if after - (setq result (cons k result) - result (cons elem result)) - (setq result (cons elem result) - result (cons k result))) - (setq result (cons k result)))) - (if anchor - (nreverse result) - (if after - (nreverse (cons elem result)) - (cons elem (nreverse result)))))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; -;;; Argument Processing -;; - -(defun use-package-only-one (label args f) - "Call F on the first member of ARGS if it has exactly one element." - (declare (indent 1)) - (cond - ((and (listp args) (listp (cdr args)) - (= (length args) 1)) - (funcall f label (car args))) - (t - (use-package-error - (concat label " wants exactly one argument"))))) - -(put 'use-package-only-one 'lisp-indent-function 'defun) - -(defun use-package-as-one (label args f &optional allow-empty) - "Call F on the first element of ARGS if it has one element, or all of ARGS. -If ALLOW-EMPTY is non-nil, it's OK for ARGS to be an empty list." - (declare (indent 1)) - (if (if args - (and (listp args) (listp (cdr args))) - allow-empty) - (if (= (length args) 1) - (funcall f label (car args)) - (funcall f label args)) - (use-package-error - (concat label " wants a non-empty list")))) - -(put 'use-package-as-one 'lisp-indent-function 'defun) - -(defun use-package-memoize (f arg) - "Ensure the macro-expansion of F applied to ARG evaluates ARG -no more than once." - (let ((loaded (cl-gentemp "use-package--loaded")) - (result (cl-gentemp "use-package--result")) - (next (cl-gentemp "use-package--next"))) - `((defvar ,loaded nil) - (defvar ,result nil) - (defvar ,next #'(lambda () (if ,loaded ,result - (setq ,loaded t ,result ,arg)))) - ,@(funcall f `((funcall ,next)))))) - -(defsubst use-package-normalize-value (_label arg) - "Normalize the Lisp value given by ARG. -The argument LABEL is ignored." - (cond ((null arg) nil) - ((eq t arg) t) - ((use-package-non-nil-symbolp arg) - `(symbol-value ',arg)) - ((functionp arg) - `(funcall #',arg)) - (t arg))) - -(defun use-package-normalize-symbols (label arg &optional recursed) - "Normalize a list of symbols." - (cond - ((use-package-non-nil-symbolp arg) - (list arg)) - ((and (not recursed) (listp arg) (listp (cdr arg))) - (mapcar #'(lambda (x) (car (use-package-normalize-symbols label x t))) arg)) - (t - (use-package-error - (concat label " wants a symbol, or list of symbols"))))) - -(defun use-package-normalize-symlist (_name keyword args) - (use-package-as-one (symbol-name keyword) args - #'use-package-normalize-symbols)) - -(defun use-package-normalize-recursive-symbols (label arg) - "Normalize a list of symbols." - (cond - ((use-package-non-nil-symbolp arg) - arg) - ((and (listp arg) (listp (cdr arg))) - (mapcar #'(lambda (x) (use-package-normalize-recursive-symbols label x)) - arg)) - (t - (use-package-error - (concat label " wants a symbol, or nested list of symbols"))))) - -(defun use-package-normalize-recursive-symlist (_name keyword args) - (use-package-as-one (symbol-name keyword) args - #'use-package-normalize-recursive-symbols)) - -(defun use-package-normalize-paths (label arg &optional recursed) - "Normalize a list of filesystem paths." - (cond - ((and arg (or (use-package-non-nil-symbolp arg) (functionp arg))) - (let ((value (use-package-normalize-value label arg))) - (use-package-normalize-paths label (eval value)))) - ((stringp arg) - (let ((path (if (file-name-absolute-p arg) - arg - (expand-file-name arg user-emacs-directory)))) - (list path))) - ((and (not recursed) (listp arg) (listp (cdr arg))) - (mapcar #'(lambda (x) - (car (use-package-normalize-paths label x t))) arg)) - (t - (use-package-error - (concat label " wants a directory path, or list of paths"))))) - -(defun use-package-normalize-predicate (_name keyword args) - (if (null args) - t - (use-package-only-one (symbol-name keyword) args - #'use-package-normalize-value))) - -(defun use-package-normalize-form (label args) - "Given a list of forms, return it wrapped in `progn'." - (unless (listp (car args)) - (use-package-error (concat label " wants a sexp or list of sexps"))) - (mapcar #'(lambda (form) - (if (and (consp form) - (memq (car form) - '(use-package bind-key bind-key* - unbind-key bind-keys bind-keys*))) - (macroexpand form) - form)) args)) - -(defun use-package-normalize-forms (_name keyword args) - (use-package-normalize-form (symbol-name keyword) args)) - -(defun use-package-normalize-pairs - (key-pred val-pred name label arg &optional recursed) - "Normalize a list of pairs. -KEY-PRED and VAL-PRED are predicates recognizing valid keys and -values, respectively. -If RECURSED is non-nil, recurse into sublists." - (cond - ((funcall key-pred arg) - (list (cons arg (use-package-as-symbol name)))) - ((use-package-is-pair arg key-pred val-pred) - (list arg)) - ((and (not recursed) (listp arg) (listp (cdr arg))) - (let (last-item) - (mapcar - #'(lambda (x) - (prog1 - (let ((ret (use-package-normalize-pairs - key-pred val-pred name label x t))) - (if (and (listp ret) - (not (keywordp last-item))) - (car ret) - ret)) - (setq last-item x))) arg))) - (t arg))) - -(defun use-package-recognize-function (v &optional binding additional-pred) - "A predicate that recognizes functional constructions: - nil - sym - 'sym - (quote sym) - #'sym - (function sym) - (lambda () ...) - '(lambda () ...) - (quote (lambda () ...)) - #'(lambda () ...) - (function (lambda () ...))" - (or (if binding - (symbolp v) - (use-package-non-nil-symbolp v)) - (and (listp v) - (memq (car v) '(quote function)) - (use-package-non-nil-symbolp (cadr v))) - (if binding (commandp v) (functionp v)) - (and additional-pred - (funcall additional-pred v)))) - -(defun use-package-normalize-function (v) - "Reduce functional constructions to one of two normal forms: - sym - #'(lambda () ...)" - (cond ((symbolp v) v) - ((and (listp v) - (memq (car v) '(quote function)) - (use-package-non-nil-symbolp (cadr v))) - (cadr v)) - ((and (consp v) - (eq 'lambda (car v))) - v) - ((and (listp v) - (memq (car v) '(quote function)) - (eq 'lambda (car (cadr v)))) - (cadr v)) - (t v))) - -(defun use-package-normalize-commands (args) - "Map over ARGS of the form ((_ . F) ...), normalizing functional F's." - (mapcar #'(lambda (x) - (if (consp x) - (cons (car x) (use-package-normalize-function (cdr x))) - x)) - args)) - -(defun use-package-normalize-mode (name keyword args) - "Normalize arguments for keywords which add regexp/mode pairs to an alist." - (use-package-as-one (symbol-name keyword) args - (apply-partially #'use-package-normalize-pairs - #'use-package-regex-p - #'use-package-recognize-function - name))) - -(defun use-package-autoloads-mode (_name _keyword args) - (mapcar - #'(lambda (x) (cons (cdr x) 'command)) - (cl-remove-if-not #'(lambda (x) - (and (consp x) - (use-package-non-nil-symbolp (cdr x)))) - args))) - -(defun use-package-handle-mode (name alist args rest state) - "Handle keywords which add regexp/mode pairs to an alist." - (use-package-concat - (use-package-process-keywords name rest state) - (mapcar - #'(lambda (thing) - `(add-to-list - ',alist - ',(cons (use-package-normalize-regex (car thing)) - (cdr thing)))) - (use-package-normalize-commands args)))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; -;;; Statistics -;; - -(defun use-package-reset-statistics () - (interactive) - (setq use-package-statistics (make-hash-table))) - -(defun use-package-statistics-status (package) - "Return loading configuration status of PACKAGE statistics." - (cond ((gethash :config package) "Configured") - ((gethash :init package) "Initialized") - ((gethash :preface package) "Prefaced") - ((gethash :use-package package) "Declared"))) - -(defun use-package-statistics-last-event (package) - "Return the date when PACKAGE's status last changed. -The date is returned as a string." - (format-time-string "%Y-%m-%d %a %H:%M" - (or (gethash :config package) - (gethash :init package) - (gethash :preface package) - (gethash :use-package package)))) - -(defun use-package-statistics-time (package) - "Return the time is took for PACKAGE to load." - (+ (float-time (gethash :config-secs package 0)) - (float-time (gethash :init-secs package 0)) - (float-time (gethash :preface-secs package 0)) - (float-time (gethash :use-package-secs package 0)))) - -(defun use-package-statistics-convert (package) - "Return information about PACKAGE. - -The information is formatted in a way suitable for -`use-package-statistics-mode'." - (let ((statistics (gethash package use-package-statistics))) - (list - package - (vector - (symbol-name package) - (use-package-statistics-status statistics) - (use-package-statistics-last-event statistics) - (format "%.2f" (use-package-statistics-time statistics)))))) - -(defun use-package-report () - "Show current statistics gathered about use-package declarations. -In the table that's generated, the status field has the following -meaning: - Configured :config has been processed (the package is loaded!) - Initialized :init has been processed (load status unknown) - Prefaced :preface has been processed - Declared the use-package declaration was seen" - (interactive) - (with-current-buffer (get-buffer-create "*use-package statistics*") - (setq tabulated-list-entries - (mapcar #'use-package-statistics-convert - (hash-table-keys use-package-statistics))) - (use-package-statistics-mode) - (tabulated-list-print) - (display-buffer (current-buffer)))) - -(define-derived-mode use-package-statistics-mode tabulated-list-mode - "use-package statistics" - "Show current statistics gathered about use-package declarations." - (setq tabulated-list-format - ;; The sum of column width is 80 caracters: - #[("Package" 25 t) - ("Status" 13 t) - ("Last Event" 23 t) - ("Time" 10 t)]) - (tabulated-list-init-header)) - -(defun use-package-statistics-gather (keyword name after) - (let* ((hash (gethash name use-package-statistics - (make-hash-table))) - (before (and after (gethash keyword hash (current-time))))) - (puthash keyword (current-time) hash) - (when after - (puthash (intern (concat (symbol-name keyword) "-secs")) - (time-subtract (current-time) before) hash)) - (puthash name hash use-package-statistics))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; -;;; Handlers -;; - -;;;; :disabled - -;; Don't alias this to `ignore', as that will cause the resulting -;; function to be interactive. -(defun use-package-normalize/:disabled (_name _keyword _arg) - "Do nothing, return nil.") - -(defun use-package-handler/:disabled (name _keyword _arg rest state) - (use-package-process-keywords name rest state)) - -;;;; :if, :when and :unless - -(defun use-package-normalize-test (_name keyword args) - (use-package-only-one (symbol-name keyword) args - #'use-package-normalize-value)) - -(defalias 'use-package-normalize/:if 'use-package-normalize-test) - -(defun use-package-handler/:if (name _keyword pred rest state) - (let ((body (use-package-process-keywords name rest state))) - `((when ,pred ,@body)))) - -(defalias 'use-package-normalize/:when 'use-package-normalize-test) - -(defalias 'use-package-handler/:when 'use-package-handler/:if) - -(defalias 'use-package-normalize/:unless 'use-package-normalize-test) - -(defun use-package-handler/:unless (name _keyword pred rest state) - (let ((body (use-package-process-keywords name rest state))) - `((unless ,pred ,@body)))) - -;;;; :requires - -(defalias 'use-package-normalize/:requires 'use-package-normalize-symlist) - -(defun use-package-handler/:requires (name _keyword requires rest state) - (let ((body (use-package-process-keywords name rest state))) - (if (null requires) - body - `((when ,(if (> (length requires) 1) - `(not (member nil (mapcar #'featurep ',requires))) - `(featurep ',(car requires))) - ,@body))))) - -;;;; :load-path - -(defun use-package-normalize/:load-path (_name keyword args) - (use-package-as-one (symbol-name keyword) args - #'use-package-normalize-paths)) - -(defun use-package-handler/:load-path (name _keyword arg rest state) - (let ((body (use-package-process-keywords name rest state))) - (use-package-concat - (mapcar #'(lambda (path) - `(eval-and-compile (add-to-list 'load-path ,path))) - arg) - body))) - -;;;; :no-require - -(defalias 'use-package-normalize/:no-require 'use-package-normalize-predicate) - -(defun use-package-handler/:no-require (name _keyword _arg rest state) - (use-package-process-keywords name rest state)) - -;;;; :defines - -(defalias 'use-package-normalize/:defines 'use-package-normalize-symlist) - -(defun use-package-handler/:defines (name _keyword _arg rest state) - (use-package-process-keywords name rest state)) - -;;;; :functions - -(defalias 'use-package-normalize/:functions 'use-package-normalize-symlist) - -(defun use-package-handler/:functions (name _keyword _arg rest state) - (use-package-process-keywords name rest state)) - -;;;; :preface - -(defalias 'use-package-normalize/:preface 'use-package-normalize-forms) - -(defun use-package-handler/:preface (name _keyword arg rest state) - (let ((body (use-package-process-keywords name rest state))) - (use-package-concat - (when use-package-compute-statistics - `((use-package-statistics-gather :preface ',name nil))) - (when arg - `((eval-and-compile ,@arg))) - body - (when use-package-compute-statistics - `((use-package-statistics-gather :preface ',name t)))))) - -;;;; :catch - -(defvar use-package--form) -(defvar use-package--hush-function #'(lambda (_keyword body) body)) - -(defsubst use-package-hush (context keyword body) - `((condition-case-unless-debug err - ,(macroexp-progn body) - (error (funcall ,context ,keyword err))))) - -(defun use-package-normalize/:catch (_name keyword args) - (if (null args) - t - (use-package-only-one (symbol-name keyword) args - use-package--hush-function))) - -(defun use-package-handler/:catch (name keyword arg rest state) - (let* ((context (cl-gentemp "use-package--warning"))) - (cond - ((not arg) - (use-package-process-keywords name rest state)) - ((eq arg t) - `((defvar ,context - #'(lambda (keyword err) - (let ((msg (format "%s/%s: %s" ',name keyword - (error-message-string err)))) - ,@(when (eq use-package-verbose 'debug) - `((with-current-buffer - (get-buffer-create "*use-package*") - (goto-char (point-max)) - (insert "-----\n" msg ,use-package--form) - (emacs-lisp-mode)) - (setq msg - (concat msg - " (see the *use-package* buffer)")))) - (display-warning 'use-package msg :error)))) - ,@(let ((use-package--hush-function - (apply-partially #'use-package-hush context))) - (funcall use-package--hush-function keyword - (use-package-process-keywords name rest state))))) - ((functionp arg) - `((defvar ,context ,arg) - ,@(let ((use-package--hush-function - (apply-partially #'use-package-hush context))) - (funcall use-package--hush-function keyword - (use-package-process-keywords name rest state))))) - (t - (use-package-error "The :catch keyword expects 't' or a function"))))) - -;;;; :interpreter - -(defalias 'use-package-normalize/:interpreter 'use-package-normalize-mode) -(defalias 'use-package-autoloads/:interpreter 'use-package-autoloads-mode) - -(defun use-package-handler/:interpreter (name _keyword arg rest state) - (use-package-handle-mode name 'interpreter-mode-alist arg rest state)) - -;;;; :mode - -(defalias 'use-package-normalize/:mode 'use-package-normalize-mode) -(defalias 'use-package-autoloads/:mode 'use-package-autoloads-mode) - -(defun use-package-handler/:mode (name _keyword arg rest state) - (use-package-handle-mode name 'auto-mode-alist arg rest state)) - -;;;; :magic - -(defalias 'use-package-normalize/:magic 'use-package-normalize-mode) -(defalias 'use-package-autoloads/:magic 'use-package-autoloads-mode) - -(defun use-package-handler/:magic (name _keyword arg rest state) - (use-package-handle-mode name 'magic-mode-alist arg rest state)) - -;;;; :magic-fallback - -(defalias 'use-package-normalize/:magic-fallback 'use-package-normalize-mode) -(defalias 'use-package-autoloads/:magic-fallback 'use-package-autoloads-mode) - -(defun use-package-handler/:magic-fallback (name _keyword arg rest state) - (use-package-handle-mode name 'magic-fallback-mode-alist arg rest state)) - -;;;; :hook - -(defun use-package-normalize/:hook (name keyword args) - (use-package-as-one (symbol-name keyword) args - #'(lambda (label arg) - (unless (or (use-package-non-nil-symbolp arg) (consp arg)) - (use-package-error - (concat label " a <symbol> or (<symbol or list of symbols> . <symbol or function>)" - " or list of these"))) - (use-package-normalize-pairs - #'(lambda (k) - (or (use-package-non-nil-symbolp k) - (and k (let ((every t)) - (while (and every k) - (if (and (consp k) - (use-package-non-nil-symbolp (car k))) - (setq k (cdr k)) - (setq every nil))) - every)))) - #'use-package-recognize-function - name label arg)))) - -(defalias 'use-package-autoloads/:hook 'use-package-autoloads-mode) - -(defun use-package-handler/:hook (name _keyword args rest state) - "Generate use-package custom keyword code." - (use-package-concat - (use-package-process-keywords name rest state) - (cl-mapcan - #'(lambda (def) - (let ((syms (car def)) - (fun (cdr def))) - (when fun - (mapcar - #'(lambda (sym) - `(add-hook - (quote ,(intern - (concat (symbol-name sym) - use-package-hook-name-suffix))) - (function ,fun))) - (if (use-package-non-nil-symbolp syms) (list syms) syms))))) - (use-package-normalize-commands args)))) - -;;;; :commands - -(defalias 'use-package-normalize/:commands 'use-package-normalize-symlist) - -(defun use-package-handler/:commands (name _keyword arg rest state) - (use-package-concat - ;; Since we deferring load, establish any necessary autoloads, and also - ;; keep the byte-compiler happy. - (let ((name-string (use-package-as-string name))) - (cl-mapcan - #'(lambda (command) - (when (symbolp command) - (append - (unless (plist-get state :demand) - `((unless (fboundp ',command) - (autoload #',command ,name-string nil t)))) - (when (bound-and-true-p byte-compile-current-file) - `((eval-when-compile - (declare-function ,command ,name-string))))))) - (delete-dups arg))) - (use-package-process-keywords name rest state))) - -;;;; :defer - -(defalias 'use-package-normalize/:defer 'use-package-normalize-predicate) - -(defun use-package-handler/:defer (name _keyword arg rest state) - (let ((body (use-package-process-keywords name rest state))) - (use-package-concat - ;; Load the package after a set amount of idle time, if the argument to - ;; `:defer' was a number. - (when (numberp arg) - `((run-with-idle-timer ,arg nil #'require - ',(use-package-as-symbol name) nil t))) - (if (or (not arg) (null body)) - body - `((eval-after-load ',name ',(macroexp-progn body))))))) - -;;;; :after - -(defun use-package-normalize/:after (name keyword args) - (setq args (use-package-normalize-recursive-symlist name keyword args)) - (if (consp args) - args - (list args))) - -(defun use-package-after-count-uses (features) - "Count the number of time the body would appear in the result." - (cond ((use-package-non-nil-symbolp features) - 1) - ((and (consp features) - (memq (car features) '(:or :any))) - (let ((num 0)) - (cl-dolist (next (cdr features)) - (setq num (+ num (use-package-after-count-uses next)))) - num)) - ((and (consp features) - (memq (car features) '(:and :all))) - (apply #'max (mapcar #'use-package-after-count-uses - (cdr features)))) - ((listp features) - (use-package-after-count-uses (cons :all features))))) - -(defun use-package-require-after-load (features body) - "Generate `eval-after-load' statements to represents FEATURES. -FEATURES is a list containing keywords `:and' and `:all', where -no keyword implies `:all'." - (cond - ((use-package-non-nil-symbolp features) - `((eval-after-load ',features ',(macroexp-progn body)))) - ((and (consp features) - (memq (car features) '(:or :any))) - (cl-mapcan #'(lambda (x) (use-package-require-after-load x body)) - (cdr features))) - ((and (consp features) - (memq (car features) '(:and :all))) - (cl-dolist (next (cdr features)) - (setq body (use-package-require-after-load next body))) - body) - ((listp features) - (use-package-require-after-load (cons :all features) body)))) - -(defun use-package-handler/:after (name _keyword arg rest state) - (let ((body (use-package-process-keywords name rest state)) - (uses (use-package-after-count-uses arg))) - (if (or (null uses) (null body)) - body - (if (<= uses 1) - (use-package-require-after-load arg body) - (use-package-memoize - (apply-partially #'use-package-require-after-load arg) - (macroexp-progn body)))))) - -;;;; :demand - -(defalias 'use-package-normalize/:demand 'use-package-normalize-predicate) - -(defun use-package-handler/:demand (name _keyword _arg rest state) - (use-package-process-keywords name rest state)) - -;;;; :custom - -(defun use-package-normalize/:custom (_name keyword args) - "Normalize use-package custom keyword." - (use-package-as-one (symbol-name keyword) args - #'(lambda (label arg) - (unless (listp arg) - (use-package-error - (concat label " a (<symbol> <value> [comment])" - " or list of these"))) - (if (use-package-non-nil-symbolp (car arg)) - (list arg) - arg)))) - -(defun use-package-handler/:custom (name _keyword args rest state) - "Generate use-package custom keyword code." - (use-package-concat - (mapcar - #'(lambda (def) - (let ((variable (nth 0 def)) - (value (nth 1 def)) - (comment (nth 2 def))) - (unless (and comment (stringp comment)) - (setq comment (format "Customized with use-package %s" name))) - `(customize-set-variable (quote ,variable) ,value ,comment))) - args) - (use-package-process-keywords name rest state))) - -;;;; :custom-face - -(defun use-package-normalize/:custom-face (name-symbol _keyword arg) - "Normalize use-package custom-face keyword." - (let ((error-msg - (format "%s wants a (<symbol> <face-spec>) or list of these" - name-symbol))) - (unless (listp arg) - (use-package-error error-msg)) - (cl-dolist (def arg arg) - (unless (listp def) - (use-package-error error-msg)) - (let ((face (nth 0 def)) - (spec (nth 1 def))) - (when (or (not face) - (not spec) - (> (length def) 2)) - (use-package-error error-msg)))))) - -(defun use-package-handler/:custom-face (name _keyword args rest state) - "Generate use-package custom-face keyword code." - (use-package-concat - (mapcar #'(lambda (def) `(custom-set-faces (quote ,def))) args) - (use-package-process-keywords name rest state))) - -;;;; :init - -(defalias 'use-package-normalize/:init 'use-package-normalize-forms) - -(defun use-package-handler/:init (name _keyword arg rest state) - (use-package-concat - (when use-package-compute-statistics - `((use-package-statistics-gather :init ',name nil))) - (let ((init-body - (use-package-hook-injector (use-package-as-string name) - :init arg))) - (when init-body - (funcall use-package--hush-function :init - (if use-package-check-before-init - `((when (locate-library ,(use-package-as-string name)) - ,@init-body)) - init-body)))) - (use-package-process-keywords name rest state) - (when use-package-compute-statistics - `((use-package-statistics-gather :init ',name t))))) - -;;;; :load - -(defun use-package-normalize/:load (name keyword args) - (setq args (use-package-normalize-recursive-symlist name keyword args)) - (if (consp args) - args - (list args))) - -(defun use-package-handler/:load (name _keyword arg rest state) - (let ((body (use-package-process-keywords name rest state))) - (cl-dolist (pkg arg) - (setq body (use-package-require (if (eq t pkg) name pkg) nil body))) - body)) - -;;;; :config - -(defalias 'use-package-normalize/:config 'use-package-normalize-forms) - -(defun use-package-handler/:config (name _keyword arg rest state) - (let* ((body (use-package-process-keywords name rest state)) - (name-symbol (use-package-as-symbol name))) - (use-package-concat - (when use-package-compute-statistics - `((use-package-statistics-gather :config ',name nil))) - (if (or (null arg) (equal arg '(t))) - body - (use-package-with-elapsed-timer - (format "Configuring package %s" name-symbol) - (funcall use-package--hush-function :config - (use-package-concat - (use-package-hook-injector - (symbol-name name-symbol) :config arg) - body - (list t))))) - (when use-package-compute-statistics - `((use-package-statistics-gather :config ',name t)))))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; -;; -;;; The main macro -;; - -(defmacro use-package-core (name args) - `(let* ((args* (use-package-normalize-keywords ,name ,args)) - (use-package--form - (if (eq use-package-verbose 'debug) - (concat "\n\n" - (pp-to-string `(use-package ,name ,@,args)) - "\n -->\n\n" - (pp-to-string `(use-package ,name ,@args*)) - "\n ==>\n\n" - (pp-to-string - (macroexp-progn - (let ((use-package-verbose 'errors) - (use-package-expand-minimally t)) - (use-package-process-keywords name args* - (and (plist-get args* :demand) - (list :demand t))))))) - ""))) - (use-package-process-keywords name args* - (and (plist-get args* :demand) - (list :demand t))))) - -;;;###autoload -(defmacro use-package (name &rest args) - "Declare an Emacs package by specifying a group of configuration options. - -For full documentation, please see the README file that came with -this file. Usage: - - (use-package package-name - [:keyword [option]]...) - -:init Code to run before PACKAGE-NAME has been loaded. -:config Code to run after PACKAGE-NAME has been loaded. Note that - if loading is deferred for any reason, this code does not - execute until the lazy load has occurred. -:preface Code to be run before everything except `:disabled'; this - can be used to define functions for use in `:if', or that - should be seen by the byte-compiler. - -:mode Form to be added to `auto-mode-alist'. -:magic Form to be added to `magic-mode-alist'. -:magic-fallback Form to be added to `magic-fallback-mode-alist'. -:interpreter Form to be added to `interpreter-mode-alist'. - -:commands Define autoloads for commands that will be defined by the - package. This is useful if the package is being lazily - loaded, and you wish to conditionally call functions in your - `:init' block that are defined in the package. - -:bind Bind keys, and define autoloads for the bound commands. -:bind* Bind keys, and define autoloads for the bound commands, - *overriding all minor mode bindings*. -:bind-keymap Bind a key prefix to an auto-loaded keymap defined in the - package. This is like `:bind', but for keymaps. -:bind-keymap* Like `:bind-keymap', but overrides all minor mode bindings - -:defer Defer loading of a package -- this is implied when using - `:commands', `:bind', `:bind*', `:mode', `:magic', - `:magic-fallback', or `:interpreter'. This can be an integer, - to force loading after N seconds of idle time, if the package - has not already been loaded. -:after Defer loading of a package until after any of the named - features are loaded. -:demand Prevent deferred loading in all cases. - -:if EXPR Initialize and load only if EXPR evaluates to a non-nil value. -:disabled The package is ignored completely if this keyword is present. -:defines Declare certain variables to silence the byte-compiler. -:functions Declare certain functions to silence the byte-compiler. -:load-path Add to the `load-path' before attempting to load the package. -:diminish Support for diminish.el (if installed). -:delight Support for delight.el (if installed). -:custom Call `customize-set-variable' with each variable definition. -:custom-face Call `customize-set-faces' with each face definition. -:ensure Loads the package using package.el if necessary. -:pin Pin the package to an archive." - (declare (indent 1)) - (unless (memq :disabled args) - (macroexp-progn - (use-package-concat - (when use-package-compute-statistics - `((use-package-statistics-gather :use-package ',name nil))) - (if (eq use-package-verbose 'errors) - (use-package-core name args) - (condition-case-unless-debug err - (use-package-core name args) - (error - (ignore - (display-warning - 'use-package - (format "Failed to parse package %s: %s" - name (error-message-string err)) :error))))) - (when use-package-compute-statistics - `((use-package-statistics-gather :use-package ',name t))))))) - -(put 'use-package 'lisp-indent-function 'defun) - -(provide 'use-package-core) - -;; Local Variables: -;; indent-tabs-mode: nil -;; End: - -;;; use-package-core.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-core.elc b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-core.elc deleted file mode 100644 index 40a1092bc94d..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-core.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-delight.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-delight.el deleted file mode 100644 index 85d5c7cb4d6d..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-delight.el +++ /dev/null @@ -1,91 +0,0 @@ -;;; use-package-delight.el --- Support for the :delight keyword -*- lexical-binding: t; -*- - -;; Copyright (C) 2012-2017 John Wiegley - -;; Author: John Wiegley <johnw@newartisans.com> -;; Maintainer: John Wiegley <johnw@newartisans.com> -;; Created: 17 Jun 2012 -;; Modified: 3 Dec 2017 -;; Version: 1.0 -;; Package-Requires: ((emacs "24.3") (use-package "2.4")) -;; Keywords: dotemacs startup speed config package -;; URL: https://github.com/jwiegley/use-package - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the GNU General Public License as -;; published by the Free Software Foundation; either version 3, 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: - -;; Provides support for the :delight keyword, which is made available by -;; default by requiring `use-package'. - -;;; Code: - -(require 'use-package-core) - -(defun use-package-normalize-delight (name args) - "Normalize ARGS for a single call to `delight'." - (when (eq :eval (car args)) - ;; Handle likely common mistake. - (use-package-error ":delight mode line constructs must be quoted")) - (cond ((and (= (length args) 1) - (use-package-non-nil-symbolp (car args))) - `(,(nth 0 args) nil ,name)) - ((= (length args) 2) - `(,(nth 0 args) ,(nth 1 args) ,name)) - ((= (length args) 3) - args) - (t - (use-package-error - ":delight expects `delight' arguments or a list of them")))) - -;;;###autoload -(defun use-package-normalize/:delight (name _keyword args) - "Normalize arguments to delight." - (cond ((null args) - `((,(use-package-as-mode name) nil ,name))) - ((and (= (length args) 1) - (use-package-non-nil-symbolp (car args))) - `((,(car args) nil ,name))) - ((and (= (length args) 1) - (stringp (car args))) - `((,(use-package-as-mode name) ,(car args) ,name))) - ((and (= (length args) 1) - (listp (car args)) - (eq 'quote (caar args))) - `((,(use-package-as-mode name) ,@(cdar args) ,name))) - ((and (= (length args) 2) - (listp (nth 1 args)) - (eq 'quote (car (nth 1 args)))) - `((,(car args) ,@(cdr (nth 1 args)) ,name))) - (t (mapcar - (apply-partially #'use-package-normalize-delight name) - (if (use-package-non-nil-symbolp (car args)) - (list args) - args))))) - -;;;###autoload -(defun use-package-handler/:delight (name _keyword args rest state) - (let ((body (use-package-process-keywords name rest state))) - (use-package-concat - body - `((if (fboundp 'delight) - (delight '(,@args))))))) - -(add-to-list 'use-package-keywords :delight t) - -(provide 'use-package-delight) - -;;; use-package-delight.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-delight.elc b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-delight.elc deleted file mode 100644 index 42b40054f7e5..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-delight.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-diminish.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-diminish.el deleted file mode 100644 index 1f3895f42cdd..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-diminish.el +++ /dev/null @@ -1,80 +0,0 @@ -;;; use-package-diminish.el --- Support for the :diminish keyword -*- lexical-binding: t; -*- - -;; Copyright (C) 2012-2017 John Wiegley - -;; Author: John Wiegley <johnw@newartisans.com> -;; Maintainer: John Wiegley <johnw@newartisans.com> -;; Created: 17 Jun 2012 -;; Modified: 3 Dec 2017 -;; Version: 1.0 -;; Package-Requires: ((emacs "24.3") (use-package "2.4")) -;; Keywords: dotemacs startup speed config package -;; URL: https://github.com/jwiegley/use-package - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the GNU General Public License as -;; published by the Free Software Foundation; either version 3, 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: - -;; Provides support for the :diminish keyword, which is made available by -;; default by requiring `use-package'. - -;;; Code: - -(require 'use-package-core) - -(defun use-package-normalize-diminish (name label arg &optional recursed) - "Normalize the arguments to diminish down to a list of one of two forms: - SYMBOL - (SYMBOL . STRING)" - (cond - ((not arg) - (list (use-package-as-mode name))) - ((use-package-non-nil-symbolp arg) - (list arg)) - ((stringp arg) - (list (cons (use-package-as-mode name) arg))) - ((and (consp arg) (stringp (cdr arg))) - (list arg)) - ((and (not recursed) (listp arg) (listp (cdr arg))) - (mapcar #'(lambda (x) (car (use-package-normalize-diminish - name label x t))) arg)) - (t - (use-package-error - (concat label " wants a string, symbol, " - "(symbol . string) or list of these"))))) - -;;;###autoload -(defun use-package-normalize/:diminish (name keyword args) - (use-package-as-one (symbol-name keyword) args - (apply-partially #'use-package-normalize-diminish name) t)) - -;;;###autoload -(defun use-package-handler/:diminish (name _keyword arg rest state) - (let ((body (use-package-process-keywords name rest state))) - (use-package-concat - (mapcar #'(lambda (var) - `(if (fboundp 'diminish) - ,(if (consp var) - `(diminish ',(car var) ,(cdr var)) - `(diminish ',var)))) - arg) - body))) - -(add-to-list 'use-package-keywords :diminish t) - -(provide 'use-package-diminish) - -;;; use-package-diminish.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-diminish.elc b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-diminish.elc deleted file mode 100644 index 409e54218ac6..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-diminish.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-ensure.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-ensure.el deleted file mode 100644 index 50005a9e9901..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-ensure.el +++ /dev/null @@ -1,214 +0,0 @@ -;;; use-package-ensure.el --- Support for the :ensure and :pin keywords -*- lexical-binding: t; -*- - -;; Copyright (C) 2012-2017 John Wiegley - -;; Author: John Wiegley <johnw@newartisans.com> -;; Maintainer: John Wiegley <johnw@newartisans.com> -;; Created: 17 Jun 2012 -;; Modified: 3 Dec 2017 -;; Version: 1.0 -;; Package-Requires: ((emacs "24.3") (use-package "2.4")) -;; Keywords: dotemacs startup speed config package -;; URL: https://github.com/jwiegley/use-package - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the GNU General Public License as -;; published by the Free Software Foundation; either version 3, 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: - -;; Provides support for the :ensure and :pin keywords, which is made available -;; by default by requiring `use-package'. - -;;; Code: - -(require 'cl-lib) -(require 'use-package-core) - -(defgroup use-package-ensure nil - "Support for :ensure and :pin keywords in use-package declarations." - :group 'use-package) - -(eval-when-compile - (declare-function package-installed-p "package") - (declare-function package-read-all-archive-contents "package" ())) - -(defcustom use-package-always-ensure nil - "Treat every package as though it had specified using `:ensure SEXP'. -See also `use-package-defaults', which uses this value." - :type 'sexp - :group 'use-package-ensure) - -(defcustom use-package-always-pin nil - "Treat every package as though it had specified using `:pin SYM'. -See also `use-package-defaults', which uses this value." - :type 'symbol - :group 'use-package-ensure) - -(defcustom use-package-ensure-function 'use-package-ensure-elpa - "Function that ensures a package is installed. -This function is called with three arguments: the name of the -package declared in the `use-package' form; the arguments passed -to all `:ensure' keywords (always a list, even if only one); and -the current `state' plist created by previous handlers. - -Note that this function is called whenever `:ensure' is provided, -even if it is nil. It is up to the function to decide on the -semantics of the various values for `:ensure'. - -This function should return non-nil if the package is installed. - -The default value uses package.el to install the package." - :type '(choice (const :tag "package.el" use-package-ensure-elpa) - (function :tag "Custom")) - :group 'use-package-ensure) - -;;;; :pin - -(defun use-package-normalize/:pin (_name keyword args) - (use-package-only-one (symbol-name keyword) args - #'(lambda (_label arg) - (cond - ((stringp arg) arg) - ((use-package-non-nil-symbolp arg) (symbol-name arg)) - (t - (use-package-error - ":pin wants an archive name (a string)")))))) - -(eval-when-compile - (defvar package-pinned-packages) - (defvar package-archives)) - -(defun use-package-archive-exists-p (archive) - "Check if a given ARCHIVE is enabled. - -ARCHIVE can be a string or a symbol or 'manual to indicate a -manually updated package." - (if (member archive '(manual "manual")) - 't - (let ((valid nil)) - (dolist (pa package-archives) - (when (member archive (list (car pa) (intern (car pa)))) - (setq valid 't))) - valid))) - -(defun use-package-pin-package (package archive) - "Pin PACKAGE to ARCHIVE." - (unless (boundp 'package-pinned-packages) - (setq package-pinned-packages ())) - (let ((archive-symbol (if (symbolp archive) archive (intern archive))) - (archive-name (if (stringp archive) archive (symbol-name archive)))) - (if (use-package-archive-exists-p archive-symbol) - (add-to-list 'package-pinned-packages (cons package archive-name)) - (error "Archive '%s' requested for package '%s' is not available." - archive-name package)) - (unless (bound-and-true-p package--initialized) - (package-initialize t)))) - -(defun use-package-handler/:pin (name _keyword archive-name rest state) - (let ((body (use-package-process-keywords name rest state)) - (pin-form (if archive-name - `(use-package-pin-package ',(use-package-as-symbol name) - ,archive-name)))) - ;; Pinning should occur just before ensuring - ;; See `use-package-handler/:ensure'. - (if (bound-and-true-p byte-compile-current-file) - (eval pin-form) ; Eval when byte-compiling, - (push pin-form body)) ; or else wait until runtime. - body)) - -;;;; :ensure - -(defvar package-archive-contents) - -;;;###autoload -(defun use-package-normalize/:ensure (_name keyword args) - (if (null args) - (list t) - (use-package-only-one (symbol-name keyword) args - #'(lambda (_label arg) - (cond - ((symbolp arg) - (list arg)) - ((and (listp arg) (= 3 (length arg)) - (symbolp (nth 0 arg)) - (eq :pin (nth 1 arg)) - (or (stringp (nth 2 arg)) - (symbolp (nth 2 arg)))) - (list (cons (nth 0 arg) (nth 2 arg)))) - (t - (use-package-error - (concat ":ensure wants an optional package name " - "(an unquoted symbol name), or (<symbol> :pin <string>)")))))))) - -(defun use-package-ensure-elpa (name args _state &optional _no-refresh) - (dolist (ensure args) - (let ((package - (or (and (eq ensure t) (use-package-as-symbol name)) - ensure))) - (when package - (require 'package) - (when (consp package) - (use-package-pin-package (car package) (cdr package)) - (setq package (car package))) - (unless (package-installed-p package) - (condition-case-unless-debug err - (progn - (when (assoc package (bound-and-true-p - package-pinned-packages)) - (package-read-all-archive-contents)) - (if (assoc package package-archive-contents) - (package-install package) - (package-refresh-contents) - (when (assoc package (bound-and-true-p - package-pinned-packages)) - (package-read-all-archive-contents)) - (package-install package)) - t) - (error - (display-warning 'use-package - (format "Failed to install %s: %s" - name (error-message-string err)) - :error)))))))) - -;;;###autoload -(defun use-package-handler/:ensure (name _keyword ensure rest state) - (let* ((body (use-package-process-keywords name rest state))) - ;; We want to avoid installing packages when the `use-package' macro is - ;; being macro-expanded by elisp completion (see `lisp--local-variables'), - ;; but still install packages when byte-compiling, to avoid requiring - ;; `package' at runtime. - (if (bound-and-true-p byte-compile-current-file) - ;; Eval when byte-compiling, - (funcall use-package-ensure-function name ensure state) - ;; or else wait until runtime. - (push `(,use-package-ensure-function ',name ',ensure ',state) - body)) - body)) - -(add-to-list 'use-package-defaults - '(:ensure (list use-package-always-ensure) - (lambda (name args) - (and use-package-always-ensure - (not (plist-member args :load-path))))) t) - -(add-to-list 'use-package-defaults - '(:pin use-package-always-pin use-package-always-pin) t) - -(add-to-list 'use-package-keywords :ensure) -(add-to-list 'use-package-keywords :pin) - -(provide 'use-package-ensure) - -;;; use-package-ensure.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-ensure.elc b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-ensure.elc deleted file mode 100644 index 88128c9779be..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-ensure.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-jump.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-jump.el deleted file mode 100644 index 4044ad165644..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-jump.el +++ /dev/null @@ -1,79 +0,0 @@ -;;; use-package-jump.el --- Attempt to jump to a use-package declaration -*- lexical-binding: t; -*- - -;; Copyright (C) 2012-2017 John Wiegley - -;; Author: John Wiegley <johnw@newartisans.com> -;; Maintainer: John Wiegley <johnw@newartisans.com> -;; Created: 17 Jun 2012 -;; Modified: 3 Dec 2017 -;; Version: 1.0 -;; Package-Requires: ((emacs "24.3") (use-package "2.4")) -;; Keywords: dotemacs startup speed config package -;; URL: https://github.com/jwiegley/use-package - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the GNU General Public License as -;; published by the Free Software Foundation; either version 3, 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: - -;; Provides the command `M-x use-package-jump-to-package-form', however it -;; only works if the package being jumped to was required during -;; initialization. If it was delay-loaded, it will not work. Improvements are -;; needed. - -;;; Code: - -(require 'use-package-core) - -(defun use-package-find-require (package) - "Find file that required PACKAGE by searching `load-history'. -Returns an absolute file path or nil if none is found." - (catch 'suspect - (dolist (filespec load-history) - (dolist (entry (cdr filespec)) - (when (equal entry (cons 'require package)) - (throw 'suspect (car filespec))))))) - -;;;###autoload -(defun use-package-jump-to-package-form (package) - "Attempt to find and jump to the `use-package' form that loaded -PACKAGE. This will only find the form if that form actually -required PACKAGE. If PACKAGE was previously required then this -function will jump to the file that originally required PACKAGE -instead." - (interactive (list (completing-read "Package: " features))) - (let* ((package (if (stringp package) (intern package) package)) - (requiring-file (use-package-find-require package)) - file location) - (if (null requiring-file) - (user-error "Can't find file requiring file; may have been autoloaded") - (setq file (if (string= (file-name-extension requiring-file) "elc") - (concat (file-name-sans-extension requiring-file) ".el") - requiring-file)) - (when (file-exists-p file) - (find-file-other-window file) - (save-excursion - (goto-char (point-min)) - (setq location - (re-search-forward - (format (eval use-package-form-regexp-eval) package) nil t))) - (if (null location) - (message "No use-package form found.") - (goto-char location) - (beginning-of-line)))))) - -(provide 'use-package-jump) - -;;; use-package-jump.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-jump.elc b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-jump.elc deleted file mode 100644 index 8bc753c56c47..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-jump.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-lint.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-lint.el deleted file mode 100644 index c6e7c3c0ce2c..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-lint.el +++ /dev/null @@ -1,84 +0,0 @@ -;;; use-package-lint.el --- Attempt to find errors in use-package declarations -*- lexical-binding: t; -*- - -;; Copyright (C) 2012-2017 John Wiegley - -;; Author: John Wiegley <johnw@newartisans.com> -;; Maintainer: John Wiegley <johnw@newartisans.com> -;; Created: 17 Jun 2012 -;; Modified: 3 Dec 2017 -;; Version: 1.0 -;; Package-Requires: ((emacs "24.3") (use-package "2.4")) -;; Keywords: dotemacs startup speed config package -;; URL: https://github.com/jwiegley/use-package - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the GNU General Public License as -;; published by the Free Software Foundation; either version 3, 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: - -;; Provides the command `M-x use-package-lint'. - -;;; Code: - -(require 'cl-lib) -(require 'use-package-core) - -(defun use-package-lint-declaration (name plist) - (dolist (path (plist-get plist :load-path)) - (unless (file-exists-p path) - (display-warning - 'use-package - (format "%s :load-path does not exist: %s" - name path) :error))) - - (unless (or (plist-member plist :disabled) - (plist-get plist :no-require) - (locate-library (use-package-as-string name) nil - (plist-get plist :load-path))) - (display-warning - 'use-package - (format "%s module cannot be located" name) :error)) - - ;; (dolist (command (plist-get plist :commands)) - ;; (unless (string= (find-lisp-object-file-name command nil) - ;; (locate-library (use-package-as-string name) nil - ;; (plist-get plist :load-path))) - ;; (display-warning - ;; 'use-package - ;; (format "%s :command is from different path: %s" - ;; name (symbol-name command)) :error))) - ) - -;;;###autoload -(defun use-package-lint () - "Check for errors in use-package declarations. -For example, if the module's `:if' condition is met, but even -with the specified `:load-path' the module cannot be found." - (interactive) - (save-excursion - (goto-char (point-min)) - (let ((re (eval use-package-form-regexp-eval))) - (while (re-search-forward re nil t) - (goto-char (match-beginning 0)) - (let ((decl (read (current-buffer)))) - (when (eq (car decl) 'use-package) - (use-package-lint-declaration - (use-package-as-string (cadr decl)) - (use-package-normalize-keywords - (cadr decl) (cddr decl))))))))) - -(provide 'use-package-lint) - -;;; use-package-lint.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-lint.elc b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-lint.elc deleted file mode 100644 index cc86871608b1..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-lint.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-pkg.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-pkg.el deleted file mode 100644 index e9364fd1f050..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package-pkg.el +++ /dev/null @@ -1,13 +0,0 @@ -(define-package "use-package" "20180715.1801" "A configuration macro for simplifying your .emacs" - '((emacs "24.3") - (bind-key "2.4")) - :keywords - '("dotemacs" "startup" "speed" "config" "package") - :authors - '(("John Wiegley" . "johnw@newartisans.com")) - :maintainer - '("John Wiegley" . "johnw@newartisans.com") - :url "https://github.com/jwiegley/use-package") -;; Local Variables: -;; no-byte-compile: t -;; End: diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.el b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.el deleted file mode 100644 index 1a8fff895f63..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.el +++ /dev/null @@ -1,54 +0,0 @@ -;;; use-package.el --- A configuration macro for simplifying your .emacs -*- lexical-binding: t; -*- - -;; Copyright (C) 2012-2017 John Wiegley - -;; Author: John Wiegley <johnw@newartisans.com> -;; Maintainer: John Wiegley <johnw@newartisans.com> -;; Created: 17 Jun 2012 -;; Modified: 29 Nov 2017 -;; Version: 2.4 -;; Package-Requires: ((emacs "24.3") (bind-key "2.4")) -;; Keywords: dotemacs startup speed config package -;; URL: https://github.com/jwiegley/use-package - -;; This program is free software; you can redistribute it and/or -;; modify it under the terms of the GNU General Public License as -;; published by the Free Software Foundation; either version 3, 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: - -;; The `use-package' declaration macro allows you to isolate package -;; configuration in your ".emacs" in a way that is performance-oriented and, -;; well, just tidy. I created it because I have over 80 packages that I use -;; in Emacs, and things were getting difficult to manage. Yet with this -;; utility my total load time is just under 1 second, with no loss of -;; functionality! -;; -;; Please see README.md from the same repository for documentation. - -;;; Code: - -(require 'use-package-core) - -(require 'use-package-bind-key) -(require 'use-package-diminish) -(require 'use-package-delight) -(require 'use-package-ensure) - -(declare-function use-package-jump-to-package-form "use-package-jump") -(autoload #'use-package-jump-to-package-form "use-package-jump" nil t) - -(provide 'use-package) - -;;; use-package.el ends here diff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.elc b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.elc deleted file mode 100644 index bcd624cfacde..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.elc +++ /dev/null Binary files differdiff --git a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.info b/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.info deleted file mode 100644 index 8058d9c80884..000000000000 --- a/configs/shared/emacs/.emacs.d/elpa/use-package-20180715.1801/use-package.info +++ /dev/null @@ -1,1048 +0,0 @@ -This is use-package.info, produced by makeinfo version 6.5 from -use-package.texi. - - Copyright (C) 2012-2017 John Wiegley <johnw@newartisans.com> - - You can redistribute this document and/or modify it under the terms - of the GNU General Public License as published by the Free Software - Foundation, either version 3 of the License, or (at your option) - any later version. - - This document 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. -INFO-DIR-SECTION Emacs -START-INFO-DIR-ENTRY -* use-package: (use-package). Declarative package configuration for Emacs. -END-INFO-DIR-ENTRY - - -File: use-package.info, Node: Top, Next: Introduction, Up: (dir) - -use-package User Manual -*********************** - -use-package is... - - Copyright (C) 2012-2017 John Wiegley <johnw@newartisans.com> - - You can redistribute this document and/or modify it under the terms - of the GNU General Public License as published by the Free Software - Foundation, either version 3 of the License, or (at your option) - any later version. - - This document 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. - -* Menu: - -* Introduction:: -* Installation:: -* Getting Started:: -* Keywords:: -* FAQ:: -* Debugging Tools:: -* Command Index:: -* Function Index:: -* Variable Index:: - -— The Detailed Node Listing — - - -Installation - -* Installing from an Elpa Archive:: -* Installing from the Git Repository:: -* Post-Installation Tasks:: - - - - -Keywords - -* ‘:after’: after. -* ‘:bind-keymap’, ‘:bind-keymap*’: bind-keymap bind-keymap*. -* ‘:bind’, ‘:bind*’: bind bind*. -* ‘:commands’: commands. -* ‘:preface’, ‘:init’, ‘:config’: preface init config. -* ‘:custom’: custom. -* ‘:custom-face’: custom-face. -* ‘:defer’, ‘:demand’: defer demand. -* ‘:defines’, ‘:functions’: defines functions. -* ‘:diminish’, ‘:delight’: diminish delight. -* ‘:disabled’: disabled. -* ‘:ensure’, ‘:pin’: ensure pin. -* ‘:hook’: hook. -* ‘:if’, ‘:when’, ‘:unless’: if when unless. -* ‘:load-path’: load-path. -* ‘:mode’, ‘:interpreter’: mode interpreter. -* ‘:magic’, ‘:magic-fallback’: magic magic-fallback. -* ‘:no-require’: no-require. -* ‘:requires’: requires. - - - -‘:bind’, ‘:bind*’ - -* Binding to local keymaps:: - -FAQ - -* FAQ - How to ...?:: -* FAQ - Issues and Errors:: - -FAQ - How to ...? - -* This is a question:: - - -FAQ - Issues and Errors - -* This is an issues:: - - -File: use-package.info, Node: Introduction, Next: Installation, Prev: Top, Up: Top - -1 Introduction -************** - -The ‘use-package’ macro allows you to isolate package configuration in -your ‘.emacs’ file in a way that is both performance-oriented and, well, -tidy. I created it because I have over 400 packages that I use in -Emacs, and things were getting difficult to manage. Yet with this -utility my total load time is around 2 seconds, with no loss of -functionality! - - -File: use-package.info, Node: Installation, Next: Getting Started, Prev: Introduction, Up: Top - -2 Installation -************** - -use-package can be installed using Emacs’ package manager or manually -from its development repository. - -* Menu: - -* Installing from an Elpa Archive:: -* Installing from the Git Repository:: -* Post-Installation Tasks:: - - -File: use-package.info, Node: Installing from an Elpa Archive, Next: Installing from the Git Repository, Up: Installation - -2.1 Installing from an Elpa Archive -=================================== - -use-package is available from Melpa and Melpa-Stable. If you haven’t -used Emacs’ package manager before, then it is high time you familiarize -yourself with it by reading the documentation in the Emacs manual, see -*note (emacs)Packages::. Then add one of the archives to -‘package-archives’: - - • To use Melpa: - - (require 'package) - (add-to-list 'package-archives - '("melpa" . "https://melpa.org/packages/") t) - - • To use Melpa-Stable: - - (require 'package) - (add-to-list 'package-archives - '("melpa-stable" . "https://stable.melpa.org/packages/") t) - - Once you have added your preferred archive, you need to update the -local package list using: - - M-x package-refresh-contents RET - - Once you have done that, you can install use-package and its -dependencies using: - - M-x package-install RET use-package RET - - Now see *note Post-Installation Tasks::. - - -File: use-package.info, Node: Installing from the Git Repository, Next: Post-Installation Tasks, Prev: Installing from an Elpa Archive, Up: Installation - -2.2 Installing from the Git Repository -====================================== - -First, use Git to clone the use-package repository: - - $ git clone https://github.com/jwiegley/use-package.git ~/.emacs.d/site-lisp/use-package - $ cd ~/.emacs.d/site-lisp/use-package - - Then compile the libraries and generate the info manuals: - - $ make - - You may need to create ‘/path/to/use-package/config.mk’ with the -following content before running ‘make’: - - LOAD_PATH = -L /path/to/use-package - - Finally add this to your init file: - - (add-to-list 'load-path "~/.emacs.d/site-lisp/use-package") - (require 'use-package) - - (with-eval-after-load 'info - (info-initialize) - (add-to-list 'Info-directory-list - "~/.emacs.d/site-lisp/use-package/")) - - Note that elements of ‘load-path’ should not end with a slash, while -those of ‘Info-directory-list’ should. - - Instead of running use-package directly from the repository by adding -it to the ‘load-path’, you might want to instead install it in some -other directory using ‘sudo make install’ and setting ‘load-path’ -accordingly. - - To update use-package use: - - $ git pull - $ make - - At times it might be necessary to run ‘make clean all’ instead. - - To view all available targets use ‘make help’. - - Now see *note Post-Installation Tasks::. - - -File: use-package.info, Node: Post-Installation Tasks, Prev: Installing from the Git Repository, Up: Installation - -2.3 Post-Installation Tasks -=========================== - -After installing use-package you should verify that you are indeed using -the use-package release you think you are using. It’s best to restart -Emacs before doing so, to make sure you are not using an outdated value -for ‘load-path’. - - C-h v use-package-version RET - - should display something like - - use-package-version’s value is "2.4" - - If you are completely new to use-package then see *note Getting -Started::. - - If you run into problems, then please see the *note FAQ::. Also see -the *note Debugging Tools::. - - -File: use-package.info, Node: Getting Started, Next: Keywords, Prev: Installation, Up: Top - -3 Getting Started -***************** - -TODO. For now, see ‘README.md’. - - -File: use-package.info, Node: Keywords, Next: FAQ, Prev: Getting Started, Up: Top - -4 Keywords -********** - -* Menu: - -* ‘:after’: after. -* ‘:bind-keymap’, ‘:bind-keymap*’: bind-keymap bind-keymap*. -* ‘:bind’, ‘:bind*’: bind bind*. -* ‘:commands’: commands. -* ‘:preface’, ‘:init’, ‘:config’: preface init config. -* ‘:custom’: custom. -* ‘:custom-face’: custom-face. -* ‘:defer’, ‘:demand’: defer demand. -* ‘:defines’, ‘:functions’: defines functions. -* ‘:diminish’, ‘:delight’: diminish delight. -* ‘:disabled’: disabled. -* ‘:ensure’, ‘:pin’: ensure pin. -* ‘:hook’: hook. -* ‘:if’, ‘:when’, ‘:unless’: if when unless. -* ‘:load-path’: load-path. -* ‘:mode’, ‘:interpreter’: mode interpreter. -* ‘:magic’, ‘:magic-fallback’: magic magic-fallback. -* ‘:no-require’: no-require. -* ‘:requires’: requires. - - -File: use-package.info, Node: after, Next: bind-keymap bind-keymap*, Up: Keywords - -4.1 ‘:after’ -============ - -Sometimes it only makes sense to configure a package after another has -been loaded, because certain variables or functions are not in scope -until that time. This can achieved using an ‘:after’ keyword that -allows a fairly rich description of the exact conditions when loading -should occur. Here is an example: - - (use-package hydra - :load-path "site-lisp/hydra") - - (use-package ivy - :load-path "site-lisp/swiper") - - (use-package ivy-hydra - :after (ivy hydra)) - - In this case, because all of these packages are demand-loaded in the -order they occur, the use of ‘:after’ is not strictly necessary. By -using it, however, the above code becomes order-independent, without an -implicit depedence on the nature of your init file. - - By default, ‘:after (foo bar)’ is the same as ‘:after (:all foo -bar)’, meaning that loading of the given package will not happen until -both ‘foo’ and ‘bar’ have been loaded. Here are some of the other -possibilities: - - :after (foo bar) - :after (:all foo bar) - :after (:any foo bar) - :after (:all (:any foo bar) (:any baz quux)) - :after (:any (:all foo bar) (:all baz quux)) - - When you nest selectors, such as ‘(:any (:all foo bar) (:all baz -quux))’, it means that the package will be loaded when either both ‘foo’ -and ‘bar’ have been loaded, or both ‘baz’ and ‘quux’ have been loaded. - - -File: use-package.info, Node: bind-keymap bind-keymap*, Next: bind bind*, Prev: after, Up: Keywords - -4.2 ‘:bind-keymap’, ‘:bind-keymap*’ -=================================== - -Normally ‘:bind’ expects that commands are functions that will be -autoloaded from the given package. However, this does not work if one -of those commands is actually a keymap, since keymaps are not functions, -and cannot be autoloaded using Emacs’ ‘autoload’ mechanism. - - To handle this case, ‘use-package’ offers a special, limited variant -of ‘:bind’ called ‘:bind-keymap’. The only difference is that the -"commands" bound to by ‘:bind-keymap’ must be keymaps defined in the -package, rather than command functions. This is handled behind the -scenes by generating custom code that loads the package containing the -keymap, and then re-executes your keypress after the first load, to -reinterpret that keypress as a prefix key. - - For example: - - (use-package projectile - :bind-keymap - ("C-c p" . projectile-command-map) - - -File: use-package.info, Node: bind bind*, Next: commands, Prev: bind-keymap bind-keymap*, Up: Keywords - -4.3 ‘:bind’, ‘:bind*’ -===================== - -Another common thing to do when loading a module is to bind a key to -primary commands within that module: - - (use-package ace-jump-mode - :bind ("C-." . ace-jump-mode)) - - This does two things: first, it creates an autoload for the -‘ace-jump-mode’ command and defers loading of ‘ace-jump-mode’ until you -actually use it. Second, it binds the key ‘C-.’ to that command. After -loading, you can use ‘M-x describe-personal-keybindings’ to see all such -keybindings you’ve set throughout your ‘.emacs’ file. - - A more literal way to do the exact same thing is: - - (use-package ace-jump-mode - :commands ace-jump-mode - :init - (bind-key "C-." 'ace-jump-mode)) - - When you use the ‘:commands’ keyword, it creates autoloads for those -commands and defers loading of the module until they are used. Since -the ‘:init’ form is always run—even if ‘ace-jump-mode’ might not be on -your system—remember to restrict ‘:init’ code to only what would succeed -either way. - - The ‘:bind’ keyword takes either a cons or a list of conses: - - (use-package hi-lock - :bind (("M-o l" . highlight-lines-matching-regexp) - ("M-o r" . highlight-regexp) - ("M-o w" . highlight-phrase))) - - The ‘:commands’ keyword likewise takes either a symbol or a list of -symbols. - - NOTE: Special keys like ‘tab’ or ‘F1’-‘Fn’ can be written in square -brackets, i.e. ‘[tab]’ instead of ‘"tab"’. The syntax for the -keybindings is similar to the "kbd" syntax: see the Emacs Manual -(https://www.gnu.org/software/emacs/manual/html_node/emacs/Init-Rebinding.html) -for more information. - - Examples: - - (use-package helm - :bind (("M-x" . helm-M-x) - ("M-<f5>" . helm-find-files) - ([f10] . helm-buffers-list) - ([S-f10] . helm-recentf))) - -* Menu: - -* Binding to local keymaps:: - - -File: use-package.info, Node: Binding to local keymaps, Up: bind bind* - -4.3.1 Binding to local keymaps ------------------------------- - -Slightly different from binding a key to a keymap, is binding a key -*within* a local keymap that only exists after the package is loaded. -‘use-package’ supports this with a ‘:map’ modifier, taking the local -keymap to bind to: - - (use-package helm - :bind (:map helm-command-map - ("C-c h" . helm-execute-persistent-action))) - - The effect of this statement is to wait until ‘helm’ has loaded, and -then to bind the key ‘C-c h’ to ‘helm-execute-persistent-action’ within -Helm’s local keymap, ‘helm-mode-map’. - - Multiple uses of ‘:map’ may be specified. Any binding occurring -before the first use of ‘:map’ are applied to the global keymap: - - (use-package term - :bind (("C-c t" . term) - :map term-mode-map - ("M-p" . term-send-up) - ("M-n" . term-send-down) - :map term-raw-map - ("M-o" . other-window) - ("M-p" . term-send-up) - ("M-n" . term-send-down))) - - -File: use-package.info, Node: commands, Next: preface init config, Prev: bind bind*, Up: Keywords - -4.4 ‘:commands’ -=============== - - -File: use-package.info, Node: preface init config, Next: custom, Prev: commands, Up: Keywords - -4.5 ‘:preface’, ‘:init’, ‘:config’ -================================== - -Here is the simplest ‘use-package’ declaration: - - ;; This is only needed once, near the top of the file - (eval-when-compile - ;; Following line is not needed if use-package.el is in ~/.emacs.d - (add-to-list 'load-path "<path where use-package is installed>") - (require 'use-package)) - - (use-package foo) - - This loads in the package ‘foo’, but only if ‘foo’ is available on -your system. If not, a warning is logged to the ‘*Messages*’ buffer. -If it succeeds, a message about ‘"Loading foo"’ is logged, along with -the time it took to load, if it took over 0.1 seconds. - - Use the ‘:init’ keyword to execute code before a package is loaded. -It accepts one or more forms, up until the next keyword: - - (use-package foo - :init - (setq foo-variable t)) - - Similarly, ‘:config’ can be used to execute code after a package is -loaded. In cases where loading is done lazily (see more about -autoloading below), this execution is deferred until after the autoload -occurs: - - (use-package foo - :init - (setq foo-variable t) - :config - (foo-mode 1)) - - As you might expect, you can use ‘:init’ and ‘:config’ together: - - (use-package color-moccur - :commands (isearch-moccur isearch-all) - :bind (("M-s O" . moccur) - :map isearch-mode-map - ("M-o" . isearch-moccur) - ("M-O" . isearch-moccur-all)) - :init - (setq isearch-lazy-highlight t) - :config - (use-package moccur-edit)) - - In this case, I want to autoload the commands ‘isearch-moccur’ and -‘isearch-all’ from ‘color-moccur.el’, and bind keys both at the global -level and within the ‘isearch-mode-map’ (see next section). When the -package is actually loaded (by using one of these commands), -‘moccur-edit’ is also loaded, to allow editing of the ‘moccur’ buffer. - - -File: use-package.info, Node: custom, Next: custom-face, Prev: preface init config, Up: Keywords - -4.6 ‘:custom’ -============= - -The ‘:custom’ keyword allows customization of package custom variables. - - (use-package comint - :custom - (comint-buffer-maximum-size 20000 "Increase comint buffer size.") - (comint-prompt-read-only t "Make the prompt read only.")) - - The documentation string is not mandatory. - - -File: use-package.info, Node: custom-face, Next: defer demand, Prev: custom, Up: Keywords - -4.7 ‘:custom-face’ -================== - -The ‘:custom-face’ keyword allows customization of package custom faces. - - (use-package eruby-mode - :custom-face - (eruby-standard-face ((t (:slant italic))))) - - -File: use-package.info, Node: defer demand, Next: defines functions, Prev: custom-face, Up: Keywords - -4.8 ‘:defer’, ‘:demand’ -======================= - -In almost all cases you don’t need to manually specify ‘:defer t’. This -is implied whenever ‘:bind’ or ‘:mode’ or ‘:interpreter’ is used. -Typically, you only need to specify ‘:defer’ if you know for a fact that -some other package will do something to cause your package to load at -the appropriate time, and thus you would like to defer loading even -though use-package isn’t creating any autoloads for you. - - You can override package deferral with the ‘:demand’ keyword. Thus, -even if you use ‘:bind’, using ‘:demand’ will force loading to occur -immediately and not establish an autoload for the bound key. - - -File: use-package.info, Node: defines functions, Next: diminish delight, Prev: defer demand, Up: Keywords - -4.9 ‘:defines’, ‘:functions’ -============================ - -Another feature of ‘use-package’ is that it always loads every file that -it can when ‘.emacs’ is being byte-compiled. This helps to silence -spurious warnings about unknown variables and functions. - - However, there are times when this is just not enough. For those -times, use the ‘:defines’ and ‘:functions’ keywords to introduce dummy -variable and function declarations solely for the sake of the -byte-compiler: - - (use-package texinfo - :defines texinfo-section-list - :commands texinfo-mode - :init - (add-to-list 'auto-mode-alist '("\\.texi$" . texinfo-mode))) - - If you need to silence a missing function warning, you can use -‘:functions’: - - (use-package ruby-mode - :mode "\\.rb\\'" - :interpreter "ruby" - :functions inf-ruby-keys - :config - (defun my-ruby-mode-hook () - (require 'inf-ruby) - (inf-ruby-keys)) - - (add-hook 'ruby-mode-hook 'my-ruby-mode-hook)) - - -File: use-package.info, Node: diminish delight, Next: disabled, Prev: defines functions, Up: Keywords - -4.10 ‘:diminish’, ‘:delight’ -============================ - -‘use-package’ also provides built-in support for the diminish and -delight utilities—if you have them installed. Their purpose is to -remove or change minor mode strings in your mode-line. - - diminish (https://github.com/myrjola/diminish.el) is invoked with the -‘:diminish’ keyword, which is passed either a minor mode symbol, a cons -of the symbol and its replacement string, or just a replacement string, -in which case the minor mode symbol is guessed to be the package name -with "-mode" appended at the end: - - (use-package abbrev - :diminish abbrev-mode - :config - (if (file-exists-p abbrev-file-name) - (quietly-read-abbrev-file))) - - delight (https://elpa.gnu.org/packages/delight.html) is invoked with -the ‘:delight’ keyword, which is passed a minor mode symbol, a -replacement string or quoted mode-line data -(https://www.gnu.org/software/emacs/manual/html_node/elisp/Mode-Line-Data.html) -(in which case the minor mode symbol is guessed to be the package name -with "-mode" appended at the end), both of these, or several lists of -both. If no arguments are provided, the default mode name is hidden -completely. - - ;; Don't show anything for rainbow-mode. - (use-package rainbow-mode - :delight) - - ;; Don't show anything for auto-revert-mode, which doesn't match - ;; its package name. - (use-package autorevert - :delight auto-revert-mode) - - ;; Remove the mode name for projectile-mode, but show the project name. - (use-package projectile - :delight '(:eval (concat " " (projectile-project-name)))) - - ;; Completely hide visual-line-mode and change auto-fill-mode to " AF". - (use-package emacs - :delight - (auto-fill-function " AF") - (visual-line-mode)) - - -File: use-package.info, Node: disabled, Next: ensure pin, Prev: diminish delight, Up: Keywords - -4.11 ‘:disabled’ -================ - -The ‘:disabled’ keyword can turn off a module you’re having difficulties -with, or stop loading something you’re not using at the present time: - - (use-package ess-site - :disabled - :commands R) - - When byte-compiling your ‘.emacs’ file, disabled declarations are -omitted from the output entirely, to accelerate startup times. - - -File: use-package.info, Node: ensure pin, Next: hook, Prev: disabled, Up: Keywords - -4.12 ‘:ensure’, ‘:pin’ -====================== - -You can use ‘use-package’ to load packages from ELPA with ‘package.el’. -This is particularly useful if you share your ‘.emacs’ among several -machines; the relevant packages are downloaded automatically once -declared in your ‘.emacs’. The ‘:ensure’ keyword causes the package(s) -to be installed automatically if not already present on your system (set -‘(setq use-package-always-ensure t)’ if you wish this behavior to be -global for all packages): - - (use-package magit - :ensure t) - - If you need to install a different package from the one named by -‘use-package’, you can specify it like this: - - (use-package tex - :ensure auctex) - - Lastly, when running on Emacs 24.4 or later, use-package can pin a -package to a specific archive, allowing you to mix and match packages -from different archives. The primary use-case for this is preferring -packages from the ‘melpa-stable’ and ‘gnu’ archives, but using specific -packages from ‘melpa’ when you need to track newer versions than what is -available in the ‘stable’ archives is also a valid use-case. - - By default ‘package.el’ prefers ‘melpa’ over ‘melpa-stable’ due to -the versioning ‘(> evil-20141208.623 evil-1.0.9)’, so even if you are -tracking only a single package from ‘melpa’, you will need to tag all -the non-‘melpa’ packages with the appropriate archive. If this really -annoys you, then you can set ‘use-package-always-pin’ to set a default. - - If you want to manually keep a package updated and ignore upstream -updates, you can pin it to ‘manual’, which as long as there is no -repository by that name, will Just Work(tm). - - ‘use-package’ throws an error if you try to pin a package to an -archive that has not been configured using ‘package-archives’ (apart -from the magic ‘manual’ archive mentioned above): - - Archive 'foo' requested for package 'bar' is not available. - - Example: - - (use-package company - :ensure t - :pin melpa-stable) - - (use-package evil - :ensure t) - ;; no :pin needed, as package.el will choose the version in melpa - - (use-package adaptive-wrap - :ensure t - ;; as this package is available only in the gnu archive, this is - ;; technically not needed, but it helps to highlight where it - ;; comes from - :pin gnu) - - (use-package org - :ensure t - ;; ignore org-mode from upstream and use a manually installed version - :pin manual) - - *NOTE*: the ‘:pin’ argument has no effect on emacs versions < 24.4. - - -File: use-package.info, Node: hook, Next: if when unless, Prev: ensure pin, Up: Keywords - -4.13 ‘:hook’ -============ - -The ‘:hook’ keyword allows adding functions onto hooks, here only the -basename of the hook is required. Thus, all of the following are -equivalent: - - (use-package ace-jump-mode - :hook prog-mode) - - (use-package ace-jump-mode - :hook (prog-mode . ace-jump-mode)) - - (use-package ace-jump-mode - :commands ace-jump-mode - :init - (add-hook 'prog-mode-hook #'ace-jump-mode)) - - And likewise, when multiple hooks should be applied, the following -are also equivalent: - - (use-package ace-jump-mode - :hook (prog-mode text-mode)) - - (use-package ace-jump-mode - :hook ((prog-mode text-mode) . ace-jump-mode)) - - (use-package ace-jump-mode - :hook ((prog-mode . ace-jump-mode) - (text-mode . ace-jump-mode))) - - (use-package ace-jump-mode - :commands ace-jump-mode - :init - (add-hook 'prog-mode-hook #'ace-jump-mode) - (add-hook 'text-mode-hook #'ace-jump-mode)) - - The use of ‘:hook’, as with ‘:bind’, ‘:mode’, ‘:interpreter’, etc., -causes the functions being hooked to implicitly be read as ‘:commands’ -(meaning they will establish interactive ‘autoload’ definitions for that -module, if not already defined as functions), and so ‘:defer t’ is also -implied by ‘:hook’. - - -File: use-package.info, Node: if when unless, Next: load-path, Prev: hook, Up: Keywords - -4.14 ‘:if’, ‘:when’, ‘:unless’ -============================== - -You can use the ‘:if’ keyword to predicate the loading and -initialization of modules. - - For example, I only want ‘edit-server’ running for my main, graphical -Emacs, not for other Emacsen I may start at the command line: - - (use-package edit-server - :if window-system - :init - (add-hook 'after-init-hook 'server-start t) - (add-hook 'after-init-hook 'edit-server-start t)) - - In another example, we can load things conditional on the operating -system: - - (use-package exec-path-from-shell - :if (memq window-system '(mac ns)) - :ensure t - :config - (exec-path-from-shell-initialize)) - - Note that ‘:when’ is provided as an alias for ‘:if’, and ‘:unless -foo’ means the same thing as ‘:if (not foo)’. - - -File: use-package.info, Node: load-path, Next: mode interpreter, Prev: if when unless, Up: Keywords - -4.15 ‘:load-path’ -================= - -If your package needs a directory added to the ‘load-path’ in order to -load, use ‘:load-path’. This takes a symbol, a function, a string or a -list of strings. If the path is relative, it is expanded within -‘user-emacs-directory’: - - (use-package ess-site - :load-path "site-lisp/ess/lisp/" - :commands R) - - Note that when using a symbol or a function to provide a dynamically -generated list of paths, you must inform the byte-compiler of this -definition so the value is available at byte-compilation time. This is -done by using the special form ‘eval-and-compile’ (as opposed to -‘eval-when-compile’). Further, this value is fixed at whatever was -determined during compilation, to avoid looking up the same information -again on each startup: - - (eval-and-compile - (defun ess-site-load-path () - (shell-command "find ~ -path ess/lisp"))) - - (use-package ess-site - :load-path (lambda () (list (ess-site-load-path))) - :commands R) - - -File: use-package.info, Node: mode interpreter, Next: magic magic-fallback, Prev: load-path, Up: Keywords - -4.16 ‘:mode’, ‘:interpreter’ -============================ - -Similar to ‘:bind’, you can use ‘:mode’ and ‘:interpreter’ to establish -a deferred binding within the ‘auto-mode-alist’ and -‘interpreter-mode-alist’ variables. The specifier to either keyword can -be a cons cell, a list of cons cells, or a string or regexp: - - (use-package ruby-mode - :mode "\\.rb\\'" - :interpreter "ruby") - - ;; The package is "python" but the mode is "python-mode": - (use-package python - :mode ("\\.py\\'" . python-mode) - :interpreter ("python" . python-mode)) - - If you aren’t using ‘:commands’, ‘:bind’, ‘:bind*’, ‘:bind-keymap’, -‘:bind-keymap*’, ‘:mode’, or ‘:interpreter’ (all of which imply -‘:defer’; see the docstring for ‘use-package’ for a brief description of -each), you can still defer loading with the ‘:defer’ keyword: - - (use-package ace-jump-mode - :defer t - :init - (autoload 'ace-jump-mode "ace-jump-mode" nil t) - (bind-key "C-." 'ace-jump-mode)) - - This does exactly the same thing as the following: - - (use-package ace-jump-mode - :bind ("C-." . ace-jump-mode)) - - -File: use-package.info, Node: magic magic-fallback, Next: no-require, Prev: mode interpreter, Up: Keywords - -4.17 ‘:magic’, ‘:magic-fallback’ -================================ - -Similar to ‘:mode‘ and ‘:interpreter‘, you can also use ‘:magic‘ and -‘:magic-fallback‘ to cause certain function to be run if the beginning -of a file matches a given regular expression. The difference between -the two is that ‘:magic-fallback‘ has a lower priority than ‘:mode‘. -For example: - - “‘ elisp (use-package pdf-tools :load-path "site-lisp/pdf-tools/lisp" -:magic ("%PDF" . pdf-view-mode) :config (pdf-tools-install)) “‘ - - This registers an autoloaded command for ‘pdf-view-mode‘, defers -loading of ‘pdf-tools‘, and runs ‘pdf-view-mode‘ if the beginning of a -buffer matches the string ‘"%PDF"‘. - - -File: use-package.info, Node: no-require, Next: requires, Prev: magic magic-fallback, Up: Keywords - -4.18 ‘:no-require’ -================== - -Normally, ‘use-package’ will load each package at compile time before -compiling the configuration, to ensure that any necessary symbols are in -scope to satisfy the byte-compiler. At times this can cause problems, -since a package may have special loading requirements, and all that you -want to use ‘use-package’ for is to add a configuration to the -‘eval-after-load’ hook. In such cases, use the ‘:no-require’ keyword: - - (use-package foo - :no-require t - :config - (message "This is evaluated when `foo' is loaded")) - - -File: use-package.info, Node: requires, Prev: no-require, Up: Keywords - -4.19 ‘:requires’ -================ - -While the ‘:after’ keyword delays loading until the dependencies are -loaded, the somewhat simpler ‘:requires’ keyword simply never loads the -package if the dependencies are not available at the time the -‘use-package’ declaration is encountered. By "available" in this -context it means that ‘foo’ is available of ‘(featurep 'foo)’ evaulates -to a non-nil value. For example: - - (use-package abbrev - :requires foo) - - This is the same as: - - (use-package abbrev - :if (featurep 'foo)) - - As a convenience, a list of such packages may be specified: - - (use-package abbrev - :requires (foo bar baz)) - - For more complex logic, such as that supported by ‘:after’, simply -use ‘:if’ and the appropriate Lisp expression. - - -File: use-package.info, Node: FAQ, Next: Debugging Tools, Prev: Keywords, Up: Top - -Appendix A FAQ -************** - -The next two nodes lists frequently asked questions. - - Please also use the *note Debugging Tools::. - -* Menu: - -* FAQ - How to ...?:: -* FAQ - Issues and Errors:: - - -File: use-package.info, Node: FAQ - How to ...?, Next: FAQ - Issues and Errors, Up: FAQ - -A.1 FAQ - How to ...? -===================== - -* Menu: - -* This is a question:: - - -File: use-package.info, Node: This is a question, Up: FAQ - How to ...? - -A.1.1 This is a question ------------------------- - -This is an answer. - - -File: use-package.info, Node: FAQ - Issues and Errors, Prev: FAQ - How to ...?, Up: FAQ - -A.2 FAQ - Issues and Errors -=========================== - -* Menu: - -* This is an issues:: - - -File: use-package.info, Node: This is an issues, Up: FAQ - Issues and Errors - -A.2.1 This is an issues ------------------------ - -This is a description. - - -File: use-package.info, Node: Debugging Tools, Next: Command Index, Prev: FAQ, Up: Top - -B Debugging Tools -***************** - -TODO - - Please also see the *note FAQ::. - - -File: use-package.info, Node: Command Index, Next: Function Index, Prev: Debugging Tools, Up: Top - -Appendix C Command Index -************************ - - -File: use-package.info, Node: Function Index, Next: Variable Index, Prev: Command Index, Up: Top - -Appendix D Function Index -************************* - - -File: use-package.info, Node: Variable Index, Prev: Function Index, Up: Top - -Appendix E Variable Index -************************* - - - -Tag Table: -Node: Top784 -Node: Introduction2819 -Node: Installation3306 -Node: Installing from an Elpa Archive3658 -Node: Installing from the Git Repository4773 -Node: Post-Installation Tasks6309 -Node: Getting Started7022 -Node: Keywords7194 -Node: after8113 -Node: bind-keymap bind-keymap*9645 -Node: bind bind*10698 -Node: Binding to local keymaps12738 -Node: commands13829 -Node: preface init config13971 -Node: custom16049 -Node: custom-face16489 -Node: defer demand16809 -Node: defines functions17621 -Node: diminish delight18766 -Node: disabled20709 -Node: ensure pin21204 -Node: hook23934 -Node: if when unless25352 -Node: load-path26298 -Node: mode interpreter27444 -Node: magic magic-fallback28755 -Node: no-require29600 -Node: requires30304 -Node: FAQ31191 -Node: FAQ - How to ...?31474 -Node: This is a question31646 -Node: FAQ - Issues and Errors31794 -Node: This is an issues31977 -Node: Debugging Tools32132 -Node: Command Index32306 -Node: Function Index32462 -Node: Variable Index32619 - -End Tag Table - - -Local Variables: -coding: utf-8 -End: |