From ebd3a1f2e6145d1aaa9022c497cff299e6756e8d Mon Sep 17 00:00:00 2001 From: Andreas Gerler Date: Sat, 21 Dec 2024 16:49:02 +0100 Subject: [PATCH] update async Signed-off-by: Andreas Gerler --- custom.el | 2 +- elpa/async-20230528.622/async-pkg.el | 14 - elpa/async-20241126.810/async-autoloads.el | 212 ++++++++++++++++ .../async-bytecomp.el | 104 ++++---- elpa/async-20241126.810/async-package.el | 145 +++++++++++ elpa/async-20241126.810/async-pkg.el | 10 + .../async.el | 73 +++++- .../dired-async.el | 46 +++- .../smtpmail-async.el | 0 .../async-await-autoloads.el | 93 +++++++ .../async-await-pkg.el | 16 ++ elpa/async-await-20220827.437/async-await.el | 239 ++++++++++++++++++ elpa/async-readme.txt | 2 - 13 files changed, 861 insertions(+), 95 deletions(-) delete mode 100644 elpa/async-20230528.622/async-pkg.el create mode 100644 elpa/async-20241126.810/async-autoloads.el rename elpa/{async-20230528.622 => async-20241126.810}/async-bytecomp.el (68%) create mode 100644 elpa/async-20241126.810/async-package.el create mode 100644 elpa/async-20241126.810/async-pkg.el rename elpa/{async-20230528.622 => async-20241126.810}/async.el (88%) rename elpa/{async-20230528.622 => async-20241126.810}/dired-async.el (91%) rename elpa/{async-20230528.622 => async-20241126.810}/smtpmail-async.el (100%) create mode 100644 elpa/async-await-20220827.437/async-await-autoloads.el create mode 100644 elpa/async-await-20220827.437/async-await-pkg.el create mode 100644 elpa/async-await-20220827.437/async-await.el delete mode 100644 elpa/async-readme.txt diff --git a/custom.el b/custom.el index 0691f014..1fecb070 100644 --- a/custom.el +++ b/custom.el @@ -33,7 +33,7 @@ '("~/org/notes.org" "~/org/motorcycles.org" "~/org/milling.org" "~/org/kitchen.org" "~/org/todo.org")) '(org-startup-folded t) '(package-selected-packages - '(soap-client dired-open-with git-gutter gh eat pinentry eshell-bookmark eshell-vterm websocket tablist sesman projectile popup pdf-tools parseclj julia-mode ivy eldoc s restclient popwin ox-pandoc key-chord json-snatcher json-reformat ht helm-bibtex go-translate flymake-easy erlang dwim-shell-command direx dired-hacks-utils closql biblio-core auto-complete-pcmp auto-complete flycheck-mmark terraform-doc hcl-mode yaxception yaml ob-graphql emacsql-sqlite docker-cli citeproc spinner symbol-overlay sqlite3 outline-minor-faces forge bibtex-completion detached atomic-chrome org-mac-link noflet pcre2el german-holidays jenkinsfile-mode cider company seq flymake log4e annotate a magit-section bicycle beacon alert graphviz-dot-mode helm-core apache-mode groovy-mode kubel solarized-theme lsp-ui docker-tramp dockerfile-mode yasnippet with-editor treepy transient simple-httpd request markdown-mode magit-popup hydra htmlize hl-todo helm f elfeed dash-functional clomacs clojure-mode async magit org lsp-mode git-link eglot helm-org biblio parsebib parseedn lv yaml-mode xah-lookup x-path-walker visual-regexp visual-ascii-mode vertica-snippets undo-tree twittering-mode tt-mode tldr terraform-mode tabulated-list sx string-inflection string-edit sqlup-mode sokoban smartparens sicp s3ed rhtml-mode restclient-helm rainbow-mode rainbow-delimiters puppet-mode paradox pacmacs package-lint ox-reveal ox-jira ox-clip org-tree-slide org-sticky-header org-ref org-plus-contrib org-mime org-jira org-chef org-ac ob-tmux ob-restclient ob-cfengine3 ob-async neotree mwe-log-commands mustache multiple-cursors mew magit-todos magit-gitflow langtool keyfreq json-mode impatient-mode highlight-symbol helm-swoop helm-safari helm-projectile helm-gtags helm-git helm-descbinds helm-c-yasnippet helm-aws guide-key graphql go-snippets go-mode gnuplot git-timemachine ggtags fullscreen-mode fullframe flymake-yaml flymake-puppet flymake-perlcritic flymake-json flycheck fast-scroll expand-region ess epoch-view engine-mode elfeed-org ejc-sql editorconfig edit-indirect dired-narrow dired+ demo-it debian-changelog-mode csv-nav csv-mode command-log-mode color-identifiers-mode centered-cursor-mode bug-hunter aws-snippets avy ascii artbollocks-mode apples-mode ac-helm)) + '(google-translate mastodon dired-git eat pinentry eshell-bookmark eshell-vterm websocket tablist sesman projectile popup pdf-tools parseclj julia-mode ivy eldoc s restclient popwin ox-pandoc key-chord json-snatcher json-reformat ht helm-bibtex go-translate flymake-easy erlang dwim-shell-command direx dired-hacks-utils closql biblio-core auto-complete-pcmp auto-complete flycheck-mmark terraform-doc hcl-mode yaxception yaml ob-graphql emacsql-sqlite docker-cli citeproc spinner symbol-overlay sqlite3 outline-minor-faces forge bibtex-completion detached atomic-chrome org-mac-link noflet pcre2el vterm german-holidays jenkinsfile-mode cider company seq flymake log4e annotate a magit-section bicycle beacon alert graphviz-dot-mode helm-core apache-mode groovy-mode kubel solarized-theme lsp-ui docker-tramp dockerfile-mode yasnippet with-editor treepy transient simple-httpd request markdown-mode magit-popup hydra htmlize hl-todo helm git-commit f elfeed dash-functional dash clomacs clojure-mode async magit org lsp-mode git-link eglot helm-org biblio parsebib parseedn lv yaml-mode xah-lookup x-path-walker visual-regexp visual-ascii-mode vertica-snippets undo-tree twittering-mode tt-mode tldr terraform-mode tabulated-list sx string-inflection string-edit sqlup-mode sokoban smartparens sicp s3ed rhtml-mode restclient-helm rainbow-mode rainbow-delimiters puppet-mode paradox pacmacs package-lint ox-reveal ox-jira ox-clip org-tree-slide org-sticky-header org-ref org-plus-contrib org-mime org-jira org-chef org-ac ob-tmux ob-restclient ob-cfengine3 ob-async neotree mwe-log-commands mustache multiple-cursors mew magit-todos magit-gitflow langtool keyfreq json-mode impatient-mode highlight-symbol helm-swoop helm-safari helm-projectile helm-gtags helm-git helm-descbinds helm-c-yasnippet helm-aws guide-key graphql go-snippets go-mode gnuplot git-timemachine ghub ggtags fullscreen-mode fullframe flymake-yaml flymake-puppet flymake-perlcritic flymake-json flycheck fast-scroll expand-region ess epoch-view engine-mode elfeed-org ejc-sql editorconfig edit-indirect dired-narrow dired+ demo-it debian-changelog-mode csv-nav csv-mode command-log-mode color-identifiers-mode centered-cursor-mode bug-hunter aws-snippets avy ascii artbollocks-mode apples-mode ac-helm)) '(package-user-dir "~/.emacs.d/elpa") '(paradox-github-token t) '(safe-local-variable-values diff --git a/elpa/async-20230528.622/async-pkg.el b/elpa/async-20230528.622/async-pkg.el deleted file mode 100644 index e6f3baff..00000000 --- a/elpa/async-20230528.622/async-pkg.el +++ /dev/null @@ -1,14 +0,0 @@ -(define-package "async" "20230528.622" "Asynchronous processing in Emacs" - '((emacs "24.4")) - :commit "3ae74c0a4ba223ba373e0cb636c385e08d8838be" :authors - '(("John Wiegley" . "jwiegley@gmail.com")) - :maintainers - '(("Thierry Volpiatto" . "thievol@posteo.net")) - :maintainer - '("Thierry Volpiatto" . "thievol@posteo.net") - :keywords - '("async") - :url "https://github.com/jwiegley/emacs-async") -;; Local Variables: -;; no-byte-compile: t -;; End: diff --git a/elpa/async-20241126.810/async-autoloads.el b/elpa/async-20241126.810/async-autoloads.el new file mode 100644 index 00000000..5dbb2341 --- /dev/null +++ b/elpa/async-20241126.810/async-autoloads.el @@ -0,0 +1,212 @@ +;;; async-autoloads.el --- automatically extracted autoloads (do not edit) -*- lexical-binding: t -*- +;; Generated by the `loaddefs-generate' function. + +;; This file is part of GNU Emacs. + +;;; Code: + +(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path))) + + + +;;; Generated autoloads from async.el + +(autoload 'async-start-process "async" "\ +Start the executable PROGRAM asynchronously named NAME. See `async-start'. +PROGRAM is passed PROGRAM-ARGS, calling FINISH-FUNC with the +process object when done. If FINISH-FUNC is nil, the future +object will return the process object when the program is +finished. Set DEFAULT-DIRECTORY to change PROGRAM's current +working directory. + +(fn NAME PROGRAM FINISH-FUNC &rest PROGRAM-ARGS)") +(autoload 'async-start "async" "\ +Execute START-FUNC (often a lambda) in a subordinate Emacs process. +When done, the return value is passed to FINISH-FUNC. Example: + + (async-start + ;; What to do in the child process + (lambda () + (message \"This is a test\") + (sleep-for 3) + 222) + + ;; What to do when it finishes + (lambda (result) + (message \"Async process done, result should be 222: %s\" + result))) + +If you call `async-send' from a child process, the message will +be also passed to the FINISH-FUNC. You can test RESULT to see if +it is a message by using `async-message-p'. If nil, it means +this is the final result. Example of the FINISH-FUNC: + + (lambda (result) + (if (async-message-p result) + (message \"Received a message from child process: %s\" result) + (message \"Async process done, result: %s\" result))) + +If FINISH-FUNC is nil or missing, a future is returned that can +be inspected using `async-get', blocking until the value is +ready. Example: + + (let ((proc (async-start + ;; What to do in the child process + (lambda () + (message \"This is a test\") + (sleep-for 3) + 222)))) + + (message \"I'm going to do some work here\") ;; .... + + (message \"Waiting on async process, result should be 222: %s\" + (async-get proc))) + +If you don't want to use a callback, and you don't care about any +return value from the child process, pass the `ignore' symbol as +the second argument (if you don't, and never call `async-get', it +will leave *emacs* process buffers hanging around): + + (async-start + (lambda () + (delete-file \"a remote file on a slow link\" nil)) + \\='ignore) + +Special case: +If the output of START-FUNC is a string with properties +e.g. (buffer-string) RESULT will be transformed in a list where the +car is the string itself (without props) and the cdr the rest of +properties, this allows using in FINISH-FUNC the string without +properties and then apply the properties in cdr to this string (if +needed). +Properties handling special objects like markers are returned as +list to allow restoring them later. +See for more infos. + +Note: Even when FINISH-FUNC is present, a future is still +returned except that it yields no value (since the value is +passed to FINISH-FUNC). Call `async-get' on such a future always +returns nil. It can still be useful, however, as an argument to +`async-ready' or `async-wait'. + +(fn START-FUNC &optional FINISH-FUNC)") +(register-definition-prefixes "async" '("async-")) + + +;;; Generated autoloads from async-bytecomp.el + +(autoload 'async-byte-recompile-directory "async-bytecomp" "\ +Compile all *.el files in DIRECTORY asynchronously. +All *.elc files are systematically deleted before proceeding. + +(fn DIRECTORY &optional QUIET)") +(defvar async-bytecomp-package-mode nil "\ +Non-nil if Async-Bytecomp-Package mode is enabled. +See the `async-bytecomp-package-mode' command +for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `async-bytecomp-package-mode'.") +(custom-autoload 'async-bytecomp-package-mode "async-bytecomp" nil) +(autoload 'async-bytecomp-package-mode "async-bytecomp" "\ +Byte compile asynchronously packages installed with package.el. + +Async compilation of packages can be controlled by +`async-bytecomp-allowed-packages'. +NOTE: Use this mode only if you install/upgrade etc... your packages +synchronously, if you use a package manager like helm-package.el which +by default is async you don't need this. + +This is a global minor mode. If called interactively, toggle the +`Async-Bytecomp-Package mode' mode. If the prefix argument is positive, +enable the mode, and if it is zero or negative, disable the mode. + +If called from Lisp, toggle the mode if ARG is `toggle'. Enable the +mode if ARG is nil, omitted, or is a positive number. Disable the mode +if ARG is a negative number. + +To check whether the minor mode is enabled in the current buffer, +evaluate `(default-value \\='async-bytecomp-package-mode)'. + +The mode's hook is called both when the mode is enabled and when it is +disabled. + +(fn &optional ARG)" t) +(autoload 'async-byte-compile-file "async-bytecomp" "\ +Byte compile Lisp code FILE asynchronously. + +Same as `byte-compile-file' but asynchronous. + +(fn FILE)" t) +(register-definition-prefixes "async-bytecomp" '("async-")) + + +;;; Generated autoloads from async-package.el + +(register-definition-prefixes "async-package" '("async-p")) + + +;;; Generated autoloads from dired-async.el + +(defvar dired-async-mode nil "\ +Non-nil if Dired-Async mode is enabled. +See the `dired-async-mode' command +for a description of this minor mode. +Setting this variable directly does not take effect; +either customize it (see the info node `Easy Customization') +or call the function `dired-async-mode'.") +(custom-autoload 'dired-async-mode "dired-async" nil) +(autoload 'dired-async-mode "dired-async" "\ +Do dired actions asynchronously. + +This is a global minor mode. If called interactively, toggle the +`Dired-Async mode' mode. If the prefix argument is positive, enable the +mode, and if it is zero or negative, disable the mode. + +If called from Lisp, toggle the mode if ARG is `toggle'. Enable the +mode if ARG is nil, omitted, or is a positive number. Disable the mode +if ARG is a negative number. + +To check whether the minor mode is enabled in the current buffer, +evaluate `(default-value \\='dired-async-mode)'. + +The mode's hook is called both when the mode is enabled and when it is +disabled. + +(fn &optional ARG)" t) +(autoload 'dired-async-do-copy "dired-async" "\ +Run ‘dired-do-copy’ asynchronously. + +(fn &optional ARG)" t) +(autoload 'dired-async-do-symlink "dired-async" "\ +Run ‘dired-do-symlink’ asynchronously. + +(fn &optional ARG)" t) +(autoload 'dired-async-do-hardlink "dired-async" "\ +Run ‘dired-do-hardlink’ asynchronously. + +(fn &optional ARG)" t) +(autoload 'dired-async-do-rename "dired-async" "\ +Run ‘dired-do-rename’ asynchronously. + +(fn &optional ARG)" t) +(register-definition-prefixes "dired-async" '("dired-async-")) + + +;;; Generated autoloads from smtpmail-async.el + +(register-definition-prefixes "smtpmail-async" '("async-smtpmail-")) + +;;; End of scraped data + +(provide 'async-autoloads) + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; no-native-compile: t +;; coding: utf-8-emacs-unix +;; End: + +;;; async-autoloads.el ends here diff --git a/elpa/async-20230528.622/async-bytecomp.el b/elpa/async-20241126.810/async-bytecomp.el similarity index 68% rename from elpa/async-20230528.622/async-bytecomp.el rename to elpa/async-20241126.810/async-bytecomp.el index 42dbab30..7f46ed91 100644 --- a/elpa/async-20230528.622/async-bytecomp.el +++ b/elpa/async-20241126.810/async-bytecomp.el @@ -22,17 +22,22 @@ ;; along with this program. If not, see . ;;; Commentary: -;; + ;; This package provide the `async-byte-recompile-directory' function ;; which allows, as the name says to recompile a directory outside of -;; your running emacs. -;; The benefit is your files will be compiled in a clean environment without -;; the old *.el files loaded. -;; Among other things, this fix a bug in package.el which recompile -;; the new files in the current environment with the old files loaded, creating -;; errors in most packages after upgrades. +;; your running emacs. Single files can be compiled with +;; `async-byte-compile-file'. The benefit is your files will be +;; compiled in a clean environment without the old *.el files +;; loaded. A mode `async-bytecomp-package-mode' is provided to +;; automatically compile packages asynchronously when installing or +;; upgrading, among other things, this fix a bug in package.el which +;; recompile the new files in the current environment with the old +;; files loaded, creating errors in most packages after upgrades. ;; -;; NB: This package is advicing the function `package--compile'. +;; NB: This package is advising the function `package--compile' when +;; `async-bytecomp-package-mode' is enabled. This mode is useful +;; only when using a synchronous package manager (e.g. M-x +;; list-package), users of M-x helm-packages don't need this anymore. ;;; Code: @@ -60,6 +65,33 @@ all packages are always compiled asynchronously." (defvar async-bytecomp-load-variable-regexp "\\`load-path\\'" "The variable used by `async-inject-variables' when (re)compiling async.") +(defun async-bytecomp--file-to-comp-buffer (file-or-dir &optional quiet type) + (let ((bn (file-name-nondirectory file-or-dir)) + (action-name (pcase type + ('file "File") + ('directory "Directory")))) + (if (file-exists-p async-byte-compile-log-file) + (let ((buf (get-buffer-create byte-compile-log-buffer)) + (n 0)) + (with-current-buffer buf + (goto-char (point-max)) + (let ((inhibit-read-only t)) + (insert-file-contents async-byte-compile-log-file) + (compilation-mode)) + (display-buffer buf) + (delete-file async-byte-compile-log-file) + (unless quiet + (save-excursion + (goto-char (point-min)) + (while (re-search-forward "^.*:Error:" nil t) + (cl-incf n))) + (if (> n 0) + (message "Failed to compile %d files in directory `%s'" n bn) + (message "%s `%s' compiled asynchronously with warnings" + action-name bn))))) + (unless quiet + (message "%s `%s' compiled asynchronously with success" action-name bn))))) + ;;;###autoload (defun async-byte-recompile-directory (directory &optional quiet) "Compile all *.el files in DIRECTORY asynchronously. @@ -73,26 +105,7 @@ All *.elc files are systematically deleted before proceeding." (load "async") (let ((call-back (lambda (&optional _ignore) - (if (file-exists-p async-byte-compile-log-file) - (let ((buf (get-buffer-create byte-compile-log-buffer)) - (n 0)) - (with-current-buffer buf - (goto-char (point-max)) - (let ((inhibit-read-only t)) - (insert-file-contents async-byte-compile-log-file) - (compilation-mode)) - (display-buffer buf) - (delete-file async-byte-compile-log-file) - (unless quiet - (save-excursion - (goto-char (point-min)) - (while (re-search-forward "^.*:Error:" nil t) - (cl-incf n))) - (if (> n 0) - (message "Failed to compile %d files in directory `%s'" n directory) - (message "Directory `%s' compiled asynchronously with warnings" directory))))) - (unless quiet - (message "Directory `%s' compiled asynchronously with success" directory)))))) + (async-bytecomp--file-to-comp-buffer directory quiet 'directory)))) (async-start `(lambda () (require 'bytecomp) @@ -140,13 +153,10 @@ All *.elc files are systematically deleted before proceeding." (memq cur-package (async-bytecomp--get-package-deps async-bytecomp-allowed-packages))) (progn - ;; FIXME: Why do we use (eq cur-package 'async) once - ;; and (string= cur-package "async") afterwards? (when (eq cur-package 'async) - (fmakunbound 'async-byte-recompile-directory)) - ;; Add to `load-path' the latest version of async and - ;; reload it when reinstalling async. - (when (string= cur-package "async") + (fmakunbound 'async-byte-recompile-directory) + ;; Add to `load-path' the latest version of async and + ;; reload it when reinstalling async. (cl-pushnew pkg-dir load-path) (load "async-bytecomp")) ;; `async-byte-recompile-directory' will add directory @@ -158,7 +168,10 @@ All *.elc files are systematically deleted before proceeding." (define-minor-mode async-bytecomp-package-mode "Byte compile asynchronously packages installed with package.el. Async compilation of packages can be controlled by -`async-bytecomp-allowed-packages'." +`async-bytecomp-allowed-packages'. +NOTE: Use this mode only if you install/upgrade etc... your packages +synchronously, if you use a package manager like helm-package.el which +by default is async you don't need this." :group 'async :global t (if async-bytecomp-package-mode @@ -173,28 +186,13 @@ Same as `byte-compile-file' but asynchronous." (interactive "fFile: ") (let ((call-back (lambda (&optional _ignore) - (let ((bn (file-name-nondirectory file))) - (if (file-exists-p async-byte-compile-log-file) - (let ((buf (get-buffer-create byte-compile-log-buffer)) - start) - (with-current-buffer buf - (goto-char (setq start (point-max))) - (let ((inhibit-read-only t)) - (insert-file-contents async-byte-compile-log-file) - (compilation-mode)) - (display-buffer buf) - (delete-file async-byte-compile-log-file) - (save-excursion - (goto-char start) - (if (re-search-forward "^.*:Error:" nil t) - (message "Failed to compile `%s'" bn) - (message "`%s' compiled asynchronously with warnings" bn))))) - (message "`%s' compiled asynchronously with success" bn)))))) + (async-bytecomp--file-to-comp-buffer file nil 'file)))) (async-start `(lambda () (require 'bytecomp) ,(async-inject-variables async-bytecomp-load-variable-regexp) - (let ((default-directory ,(file-name-directory file))) + (let ((default-directory ,(file-name-directory file)) + error-data) (add-to-list 'load-path default-directory) (byte-compile-file ,file) (when (get-buffer byte-compile-log-buffer) diff --git a/elpa/async-20241126.810/async-package.el b/elpa/async-20241126.810/async-package.el new file mode 100644 index 00000000..d6c58236 --- /dev/null +++ b/elpa/async-20241126.810/async-package.el @@ -0,0 +1,145 @@ +;;; async-package.el --- Fetch packages asynchronously -*- lexical-binding: t -*- + +;; Copyright (C) 2014-2022 Free Software Foundation, Inc. + +;; Author: Thierry Volpiatto + +;; Keywords: dired async byte-compile package +;; X-URL: https://github.com/jwiegley/emacs-async + +;; This program is free software; you can redistribute it and/or modify +;; it under the terms of the GNU General Public License as published by +;; the Free Software Foundation, either version 3 of the License, 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 this program. If not, see . + +;;; Commentary: + +;; Provide the function `async-package-do-action' to +;; (re)install/upgrade packages asynchronously. + +;;; Code: + +(eval-when-compile (require 'cl-lib)) +(require 'async-bytecomp) +(require 'dired-async) +(require 'package) + +(define-minor-mode async-package--modeline-mode + "Notify mode-line that an async process run." + :group 'async + :global t + :lighter (:eval (propertize (format " [%s async job Installing package(s)]" + (length (dired-async-processes + 'async-pkg-install))) + 'face 'async-package-message)) + (unless async-package--modeline-mode + (let ((visible-bell t)) (ding)))) + +(defvar async-pkg-install-after-hook nil + "Hook that run after package installation. +The hook runs in the call-back once installation is done in child emacs.") + +(defface async-package-message + '((t (:foreground "yellow"))) + "Face used for mode-line message." + :group 'async) + +(defun async-package-do-action (action packages error-file) + "Execute ACTION asynchronously on PACKAGES. +Argument ACTION can be one of \\='install, \\='upgrade, \\='reinstall. +Argument PACKAGES is a list of packages (symbols). +Argument ERROR-FILE is the file where errors are logged, if some." + (require 'async-bytecomp) + (let ((fn (pcase action + ('install 'package-install) + ('upgrade 'package-upgrade) + ('reinstall 'package-reinstall))) + (action-string (pcase action + ('install "Installing") + ('upgrade "Upgrading") + ('reinstall "Reinstalling")))) + (message "%s %s package(s)..." action-string (length packages)) + (process-put + (async-start + `(lambda () + (require 'bytecomp) + (setq package-archives ',package-archives + package-pinned-packages ',package-pinned-packages + package-archive-contents ',package-archive-contents + package-user-dir ,package-user-dir + package-alist ',package-alist + load-path ',load-path) + ;; Ensure `async-bytecomp-package-mode' doesn't kick in + ;; (issue #194) as some packages may enable it + ;; inconditionally. We don't need to compile async as we are + ;; already async and in a clean environment. + (require 'async-bytecomp) + (setq async-bytecomp-allowed-packages nil) + (prog1 + (condition-case err + (mapc ',fn ',packages) + (error + (with-temp-file ,error-file + (insert + (format + "%S:\n Please refresh package list before %s" + err ,action-string))))) + (let (error-data) + (when (get-buffer byte-compile-log-buffer) + (setq error-data (with-current-buffer byte-compile-log-buffer + (buffer-substring-no-properties + (point-min) (point-max)))) + (unless (string= error-data "") + (with-temp-file ,async-byte-compile-log-file + (erase-buffer) + (insert error-data))))))) + (lambda (result) + (if (file-exists-p error-file) + (let ((buf (find-file-noselect error-file))) + (pop-to-buffer + buf '(nil . ((window-height . fit-window-to-buffer)))) + (special-mode) + (delete-file error-file) + (async-package--modeline-mode -1)) + (when result + (let ((pkgs (if (listp result) result (list result)))) + (when (eq action 'install) + (customize-save-variable + 'package-selected-packages + (delete-dups (append pkgs package-selected-packages)))) + (package-load-all-descriptors) ; refresh package-alist. + (mapc #'package-activate pkgs) ; load packages. + (async-package--modeline-mode -1) + (message "%s %s packages done" action-string (length packages)) + (run-with-timer + 0.1 nil + (lambda (lst str) + (dired-async-mode-line-message + "%s %d package(s) done" + 'async-package-message + str (length lst))) + packages action-string) + (when (file-exists-p async-byte-compile-log-file) + (let ((buf (get-buffer-create byte-compile-log-buffer))) + (with-current-buffer buf + (goto-char (point-max)) + (let ((inhibit-read-only t)) + (insert-file-contents async-byte-compile-log-file) + (compilation-mode)) + (display-buffer buf) + (delete-file async-byte-compile-log-file))))))) + (run-hooks 'async-pkg-install-after-hook))) + 'async-pkg-install t) + (async-package--modeline-mode 1))) + +(provide 'async-package) + +;;; async-package.el ends here diff --git a/elpa/async-20241126.810/async-pkg.el b/elpa/async-20241126.810/async-pkg.el new file mode 100644 index 00000000..d736158f --- /dev/null +++ b/elpa/async-20241126.810/async-pkg.el @@ -0,0 +1,10 @@ +;; -*- no-byte-compile: t; lexical-binding: nil -*- +(define-package "async" "20241126.810" + "Asynchronous processing in Emacs." + '((emacs "24.4")) + :url "https://github.com/jwiegley/emacs-async" + :commit "b99658e831bc7e7d20ed4bb0a85bdb5c7dd74142" + :revdesc "b99658e831bc" + :keywords '("async") + :authors '(("John Wiegley" . "jwiegley@gmail.com")) + :maintainers '(("Thierry Volpiatto" . "thievol@posteo.net"))) diff --git a/elpa/async-20230528.622/async.el b/elpa/async-20241126.810/async.el similarity index 88% rename from elpa/async-20230528.622/async.el rename to elpa/async-20241126.810/async.el index e181773d..3842571c 100644 --- a/elpa/async-20230528.622/async.el +++ b/elpa/async-20241126.810/async.el @@ -6,7 +6,8 @@ ;; Maintainer: Thierry Volpiatto ;; Created: 18 Jun 2012 -;; Version: 1.9.7 +;; Package-Version: 20241126.810 +;; Package-Revision: b99658e831bc ;; Package-Requires: ((emacs "24.4")) ;; Keywords: async @@ -34,6 +35,8 @@ (eval-when-compile (require 'cl-lib)) +(defvar tramp-password-prompt-regexp) + (defgroup async nil "Simple asynchronous processing in Emacs" :group 'lisp) @@ -42,6 +45,19 @@ "Default function to remove text properties in variables." :type 'function) +(defcustom async-prompt-for-password t + "Prompt for password in parent Emacs if needed when non nil. +When this is nil child Emacs will hang forever when a user interaction +for password is required unless a password is stored in a \".authinfo\" file." + :type 'boolean) + +(defvar async-process-noquery-on-exit nil + "Used as the :noquery argument to `make-process'. + +Intended to be let-bound around a call to `async-start' or +`async-start-process'. If non-nil, the child Emacs process will +be silently killed if the user exits the parent Emacs.") + (defvar async-debug nil) (defvar async-send-over-pipe t) (defvar async-in-child-emacs nil) @@ -102,14 +118,17 @@ is returned unmodified." collect elm)) (t object))) +(defvar async-inject-variables-exclude-regexps '("-syntax-table\\'") + "A list of regexps that `async-inject-variables' should ignore.") + (defun async-inject-variables (include-regexp &optional predicate exclude-regexp noprops) "Return a `setq' form that replicates part of the calling environment. It sets the value for every variable matching INCLUDE-REGEXP and also PREDICATE. It will not perform injection for any variable -matching EXCLUDE-REGEXP (if present) or representing a `syntax-table' -i.e. ending by \"-syntax-table\". +matching EXCLUDE-REGEXP (if present) and variables matching one of +`async-inject-variables-exclude-regexps'. When NOPROPS is non nil it tries to strip out text properties of each variable's value with `async-variables-noprops-function'. @@ -128,14 +147,16 @@ It is intended to be used as follows: ,@(let (bindings) (mapatoms (lambda (sym) - (let* ((sname (and (boundp sym) (symbol-name sym))) - (value (and sname (symbol-value sym)))) + (let ((sname (and (boundp sym) (symbol-name sym))) + value) (when (and sname (or (null include-regexp) (string-match include-regexp sname)) (or (null exclude-regexp) (not (string-match exclude-regexp sname))) - (not (string-match "-syntax-table\\'" sname))) + (cl-loop for re in async-inject-variables-exclude-regexps + never (string-match-p re sname))) + (setq value (symbol-value sym)) (unless (or (stringp value) (memq value '(nil t)) (numberp value) @@ -207,7 +228,7 @@ It is intended to be used as follows: (process-name proc) (process-exit-status proc)))) (set (make-local-variable 'async-callback-value-set) t)))))) -(defun async-read-from-client (proc string) +(defun async-read-from-client (proc string &optional prompt-for-pwd) "Process text from client process. The string chunks usually arrive in maximum of 4096 bytes, so a @@ -217,8 +238,18 @@ function. We use a marker `async-read-marker' to track the position of the lasts complete line. Every time we get new input, we try to look for newline, and if found, process the entire line and bump the -marker position to the end of this next line." +marker position to the end of this next line. + +Argument PROMPT-FOR-PWD allow binding lexically the value of +`async-prompt-for-password', if unspecified its global value +is used." (with-current-buffer (process-buffer proc) + (when (and prompt-for-pwd + (boundp 'tramp-password-prompt-regexp) + tramp-password-prompt-regexp + (string-match tramp-password-prompt-regexp string)) + (process-send-string + proc (concat (read-passwd (match-string 0 string)) "\n"))) (goto-char (point-max)) (save-excursion (insert string)) @@ -350,7 +381,7 @@ its FINISH-FUNC is nil." (plist-get value :async-message))) (defun async-send (process-or-key &rest args) - "Send the given message to the asychronous child or parent Emacs. + "Send the given message to the asynchronous child or parent Emacs. To send messages from the parent to a child, PROCESS-OR-KEY is the child process object. ARGS is a plist. Example: @@ -402,12 +433,14 @@ finished. Set DEFAULT-DIRECTORY to change PROGRAM's current working directory." (let* ((buf (generate-new-buffer (concat "*" name "*"))) (buf-err (generate-new-buffer (concat "*" name ":err*"))) + (prt-for-pwd async-prompt-for-password) (proc (let ((process-connection-type nil)) (make-process :name name :buffer buf :stderr buf-err - :command (cons program program-args))))) + :command (cons program program-args) + :noquery async-process-noquery-on-exit)))) (set-process-sentinel (get-buffer-process buf-err) (lambda (proc _change) @@ -418,9 +451,12 @@ working directory." (set (make-local-variable 'async-read-marker) (set-marker (make-marker) (point-min) buf)) (set-marker-insertion-type async-read-marker nil) - (set-process-sentinel proc #'async-when-done) - (set-process-filter proc #'async-read-from-client) + ;; Pass the value of `async-prompt-for-password' to the process + ;; filter fn through the lexical local var prt-for-pwd (Issue#182). + (set-process-filter proc (lambda (proc string) + (async-read-from-client + proc string prt-for-pwd))) (unless (string= name "emacs") (set (make-local-variable 'async-callback-for-process) t)) proc))) @@ -431,11 +467,20 @@ Can be one of \"-Q\" or \"-q\". Default is \"-Q\" but it is sometimes useful to use \"-q\" to have a enhanced config or some more variables loaded.") +(defvar async-library nil + "Cache async library path. +It is useful only when you run multiple async processes in a loop, to +avoid calling many times `locate-library' which is costly. +This variable should be let bound around an `async-start' call and not +used globally. Should be found with `locate-library'.") + (defun async--emacs-program-args (&optional sexp) "Return a list of arguments for invoking the child Emacs." ;; Using `locate-library' ensure we use the right file - ;; when the .elc have been deleted. - (let ((args (list async-quiet-switch "-l" (locate-library "async")))) + ;; when the .elc have been deleted, its result can be cached in + ;; `async-library' see Issue#193. + (let ((args (list async-quiet-switch "-l" (or async-library + (locate-library "async"))))) (when async-child-init (setq args (append args (list "-l" async-child-init)))) (append args (list "-batch" "-f" "async-batch-invoke" diff --git a/elpa/async-20230528.622/dired-async.el b/elpa/async-20241126.810/dired-async.el similarity index 91% rename from elpa/async-20230528.622/dired-async.el rename to elpa/async-20241126.810/dired-async.el index 8294271a..43dcfdc0 100644 --- a/elpa/async-20230528.622/dired-async.el +++ b/elpa/async-20241126.810/dired-async.el @@ -81,6 +81,10 @@ or rename for `dired-async-skip-fast'." :risky t :type 'integer) +(defcustom dired-async-large-file-warning-threshold large-file-warning-threshold + "Same as `large-file-warning-threshold' but for dired-async." + :type 'integer) + (defface dired-async-message '((t (:foreground "yellow"))) "Face used for mode-line message.") @@ -115,9 +119,9 @@ or rename for `dired-async-skip-fast'." (sit-for 3) (force-mode-line-update))) -(defun dired-async-processes () +(defun dired-async-processes (&optional propname) (cl-loop for p in (process-list) - when (process-get p 'dired-async-process) + when (process-get p (or propname 'dired-async-process)) collect p)) (defun dired-async-kill-process () @@ -242,6 +246,14 @@ cases if `dired-async-skip-fast' is non-nil." (funcall old-func file-creator operation (nreverse quick-list) name-constructor marker-char)))) +(defun dired-async--abort-if-file-too-large (size op-type filename) + "Warn when FILENAME larger than `dired-async-large-file-warning-threshold'. +Same as `abort-if-file-too-large' but without user-error." + (when (and dired-async-large-file-warning-threshold size + (> size dired-async-large-file-warning-threshold)) + (files--ask-user-about-large-file + size op-type filename nil))) + (defvar overwrite-query) (defun dired-async-create-files (file-creator operation fn-list name-constructor &optional _marker-char) @@ -299,14 +311,22 @@ ESC or `q' to not overwrite any of the remaining files, (file-in-directory-p destname from) (error "Cannot copy `%s' into its subdirectory `%s'" from to))) - (if overwrite - (or (and dired-overwrite-confirmed - (push (cons from to) async-fn-list)) - (progn - (push (dired-make-relative from) failures) - (dired-log "%s `%s' to `%s' failed\n" - operation from to))) - (push (cons from to) async-fn-list))))) + ;; Skip file if it is too large. + (if (and (member operation '("Copy" "Rename")) + (eq (dired-async--abort-if-file-too-large + (file-attribute-size + (file-attributes (file-truename from))) + (downcase operation) from) + 'abort)) + (push from skipped) + (if overwrite + (or (and dired-overwrite-confirmed + (push (cons from to) async-fn-list)) + (progn + (push (dired-make-relative from) failures) + (dired-log "%s `%s' to `%s' failed\n" + operation from to))) + (push (cons from to) async-fn-list)))))) ;; Fix tramp issue #80 with emacs-26, use "-q" only when needed. (setq async-quiet-switch (if (and (boundp 'tramp-cache-read-persistent-data) @@ -361,10 +381,14 @@ ESC or `q' to not overwrite any of the remaining files, (async-start `(lambda () (require 'cl-lib) (require 'dired-aux) (require 'dired-x) ,(async-inject-variables dired-async-env-variables-regexp) + (advice-add #'files--ask-user-about-large-file + :override (lambda (&rest args) nil)) (let ((dired-recursive-copies (quote always)) (dired-copy-preserve-time ,dired-copy-preserve-time) - (dired-create-destination-dirs ',create-dir)) + (dired-create-destination-dirs ',create-dir) + (dired-vc-rename-file ,dired-vc-rename-file) + auth-source-save-behavior) (setq overwrite-backup-query nil) ;; Inline `backup-file' as long as it is not ;; available in emacs. diff --git a/elpa/async-20230528.622/smtpmail-async.el b/elpa/async-20241126.810/smtpmail-async.el similarity index 100% rename from elpa/async-20230528.622/smtpmail-async.el rename to elpa/async-20241126.810/smtpmail-async.el diff --git a/elpa/async-await-20220827.437/async-await-autoloads.el b/elpa/async-await-20220827.437/async-await-autoloads.el new file mode 100644 index 00000000..b760a5d4 --- /dev/null +++ b/elpa/async-await-20220827.437/async-await-autoloads.el @@ -0,0 +1,93 @@ +;;; async-await-autoloads.el --- automatically extracted autoloads (do not edit) -*- lexical-binding: t -*- +;; Generated by the `loaddefs-generate' function. + +;; This file is part of GNU Emacs. + +;;; Code: + +(add-to-list 'load-path (or (and load-file-name (directory-file-name (file-name-directory load-file-name))) (car load-path))) + + + +;;; Generated autoloads from async-await.el + +(autoload 'async-defun "async-await" "\ +Define NAME as a Async Function which return Promise. +ARGLIST should take the same form as an argument list for a `defun'. +BODY should be a list of Lisp expressions. + + (defun wait-async (n) + (promise-new (lambda (resolve _reject) + (run-at-time n + nil + (lambda () + (funcall resolve n)))))) + + (async-defun foo-async () + (print (await (wait-async 0.5))) + (message \"---\") + + (print (await (wait-async 1.0))) + (message \"---\") + + (print (await (wait-async 1.5))) + (message \"---\") + + (message \"await done\")) + + (foo-async) + +(fn NAME ARGLIST &rest BODY)" nil t) +(function-put 'async-defun 'doc-string-elt 3) +(function-put 'async-defun 'lisp-indent-function 2) +(autoload 'async-lambda "async-await" "\ +Return a lambda Async Function which return Promise. +ARGLIST should take the same form as an argument list for a `defun'. +BODY should be a list of Lisp expressions. + + (defun wait-async (n) + (promise-new (lambda (resolve _reject) + (run-at-time n + nil + (lambda () + (funcall resolve n)))))) + + (setq foo-async (async-lambda () + (print (await (wait-async 0.5))) + (message \"---\") + + (print (await (wait-async 1.0))) + (message \"---\") + + (print (await (wait-async 1.5))) + (message \"---\") + + (message \"await done\"))) + + (funcall foo-async) + +(fn ARGLIST &rest BODY)" nil t) +(function-put 'async-lambda 'doc-string-elt 2) +(function-put 'async-lambda 'lisp-indent-function 'defun) +(autoload 'async-await-advice-make-autoload "async-await" "\ +Advice function for `make-autoload'. +FN is original function and ARGS is list of arguments. +See \"For complex cases\" section in `make-autoload'. + +(fn FN &rest ARGS)") +(advice-add 'make-autoload :around #'async-await-advice-make-autoload) +(register-definition-prefixes "async-await" '("async-await-")) + +;;; End of scraped data + +(provide 'async-await-autoloads) + +;; Local Variables: +;; version-control: never +;; no-byte-compile: t +;; no-update-autoloads: t +;; no-native-compile: t +;; coding: utf-8-emacs-unix +;; End: + +;;; async-await-autoloads.el ends here diff --git a/elpa/async-await-20220827.437/async-await-pkg.el b/elpa/async-await-20220827.437/async-await-pkg.el new file mode 100644 index 00000000..7caf3d31 --- /dev/null +++ b/elpa/async-await-20220827.437/async-await-pkg.el @@ -0,0 +1,16 @@ +(define-package "async-await" "20220827.437" "Async/Await" + '((emacs "25.1") + (promise "1.1") + (iter2 "0.9.10")) + :commit "e0d15e8057ed7520100bc50c5552278292ebcb07" :authors + '(("chuntaro" . "chuntaro@sakura-games.jp")) + :maintainers + '(("chuntaro" . "chuntaro@sakura-games.jp")) + :maintainer + '("chuntaro" . "chuntaro@sakura-games.jp") + :keywords + '("async" "await" "convenience") + :url "https://github.com/chuntaro/emacs-async-await") +;; Local Variables: +;; no-byte-compile: t +;; End: diff --git a/elpa/async-await-20220827.437/async-await.el b/elpa/async-await-20220827.437/async-await.el new file mode 100644 index 00000000..a94b139f --- /dev/null +++ b/elpa/async-await-20220827.437/async-await.el @@ -0,0 +1,239 @@ +;;; async-await.el --- Async/Await -*- lexical-binding: t; -*- + +;; Copyright (C) 2017 chuntaro + +;; Author: chuntaro +;; URL: https://github.com/chuntaro/emacs-async-await +;; Package-Requires: ((emacs "25.1") (promise "1.1") (iter2 "0.9.10")) +;; Version: 1.1 +;; Keywords: async await convenience + +;; 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 of the License, 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 this program. If not, see . + +;;; Commentary: + +;; This is a simple implementation of Async/Await. +;; Inspired by the Async/Await implementation of TypeScript. +;; +;; Usage: +;; See `async-await-examples.el' for details. +;; https://raw.githubusercontent.com/chuntaro/emacs-async-await/master/examples/async-await-examples.el +;; You can check the operation while downloading and running it interactively. +;; +;; (require 'async-await) +;; +;; ;; Please be sure to enable it when developing. +;; (promise-rejection-tracking-enable '((all-rejections . t))) +;; +;; (defun wait-async (n) +;; (promise-new (lambda (resolve _reject) +;; (run-at-time n +;; nil +;; (lambda () +;; (funcall resolve n)))))) +;; +;; (async-defun example2 () +;; (print (await (wait-async 0.5))) +;; (message "---") +;; +;; (print (await (wait-async 1.0))) +;; (message "---") +;; +;; (print (await (wait-async 1.5))) +;; (message "---") +;; +;; (message "await done")) +;; +;; (example2) => +;; +;; 0.5 +;; +;; --- +;; +;; 1.0 +;; +;; --- +;; +;; 1.5 +;; +;; --- +;; await done +;; +;; The result of the execution is outputted from the top to the bottom +;; like the order written in the code. However, asynchronously! + +;;; Code: + +(require 'promise) +(require 'iter2) + +(defconst async-await--is-error (cl-gensym "async/await--error")) + +(defsubst async-await--iter-throw (iterator value) + (iter-next iterator (list async-await--is-error iterator value))) + +(defun async-await--awaiter (iterator) + (promise-new + (lambda (resolve reject) + (cl-labels ((fulfilled (value) + (condition-case reason + (step (iter-next iterator value)) + (iter-end-of-sequence (funcall resolve (cdr reason))) + (error (funcall reject reason)))) + (rejected (value) + ;; Please implement `iter-throw'! + ;; Even if you raise an exception here, Promise will be swallowed. + ;; Therefore, it is included in the return value and propagated. + (condition-case reason + (step (async-await--iter-throw iterator value)) + (iter-end-of-sequence (funcall resolve (cdr reason))) + (error (funcall reject reason)))) + (step (result) + (promise-chain (promise-resolve result) + (then #'fulfilled #'rejected)))) + (condition-case nil + (step (iter-next iterator)) + (iter-end-of-sequence nil)))))) + +(defsubst async-await--check-return-value (value) + (when (and (consp value) + (eq (car value) async-await--is-error)) + (iter-close (cl-second value)) + (signal 'error (list (cl-third value)))) + value) + +;; (defmacro await (value) +;; "When called internally in Async Function, wait until Promise is resolved. +;; VALUE can be any object other than Promise. +;; +;; (async-defun foo-async () +;; (print (await (wait-async 0.5))) +;; (print (await 3)))" +;; (identity value) +;; (error "`await' expression is only allowed within an async function")) + +;;;###autoload +(defmacro async-defun (name arglist &rest body) + "Define NAME as a Async Function which return Promise. +ARGLIST should take the same form as an argument list for a `defun'. +BODY should be a list of Lisp expressions. + + (defun wait-async (n) + (promise-new (lambda (resolve _reject) + (run-at-time n + nil + (lambda () + (funcall resolve n)))))) + + (async-defun foo-async () + (print (await (wait-async 0.5))) + (message \"---\") + + (print (await (wait-async 1.0))) + (message \"---\") + + (print (await (wait-async 1.5))) + (message \"---\") + + (message \"await done\")) + + (foo-async)" + (declare (doc-string 3) (indent 2)) + (cl-assert lexical-binding) + (let* ((parsed-body (macroexp-parse-body body)) + (declarations (car parsed-body)) + (exps (macroexpand-all + `(cl-macrolet + ((await (value) + `(async-await--check-return-value (iter-yield ,value)))) + ,@(cdr parsed-body)) + macroexpand-all-environment))) + `(defun ,name ,arglist + ,@declarations + (async-await--awaiter + (funcall (iter2-lambda () ,exps)))))) + +;;;###autoload +(defmacro async-lambda (arglist &rest body) + "Return a lambda Async Function which return Promise. +ARGLIST should take the same form as an argument list for a `defun'. +BODY should be a list of Lisp expressions. + + (defun wait-async (n) + (promise-new (lambda (resolve _reject) + (run-at-time n + nil + (lambda () + (funcall resolve n)))))) + + (setq foo-async (async-lambda () + (print (await (wait-async 0.5))) + (message \"---\") + + (print (await (wait-async 1.0))) + (message \"---\") + + (print (await (wait-async 1.5))) + (message \"---\") + + (message \"await done\"))) + + (funcall foo-async)" + (declare (doc-string 2) (indent defun)) + (cl-assert lexical-binding) + (let ((exps (macroexpand-all + `(cl-macrolet + ((await (value) + `(async-await--check-return-value (iter-yield ,value)))) + ,@body) + macroexpand-all-environment))) + `(lambda ,arglist + (async-await--awaiter + (funcall (iter2-lambda () ,exps)))))) + +(defconst async-await-font-lock-keywords + '(("(\\(async-defun\\)\\_>[ \t']*\\(\\(?:\\sw\\|\\s_\\)+\\)?" + (1 font-lock-keyword-face) + (2 font-lock-function-name-face nil t)))) + +(font-lock-add-keywords 'emacs-lisp-mode async-await-font-lock-keywords) + +(declare-function make-autoload "autoload") + +;;;###autoload +(defun async-await-advice-make-autoload (fn &rest args) + "Advice function for `make-autoload'. +FN is original function and ARGS is list of arguments. +See \"For complex cases\" section in `make-autoload'." + (seq-let (form file _expansion) args + (let ((car (car-safe form)) expand) + (cond + ;; For complex cases, try again on the macro-expansion. + ((and (eq car 'async-defun) + (macrop car) + (setq expand (let ((load-file-name file)) (macroexpand form))) + (memq (car expand) '(progn prog1 defalias))) + ;; Recurse on the expansion. + (make-autoload expand file 'expansion)) + (t + (apply fn args)))))) + +;;;###autoload +(advice-add 'make-autoload :around #'async-await-advice-make-autoload) + +(add-to-list 'lisp-imenu-generic-expression + (list nil (concat "^\\s-*(async-defun\\s-+\\(" lisp-mode-symbol-regexp "\\)") 1)) + +(provide 'async-await) +;;; async-await.el ends here diff --git a/elpa/async-readme.txt b/elpa/async-readme.txt deleted file mode 100644 index ac103499..00000000 --- a/elpa/async-readme.txt +++ /dev/null @@ -1,2 +0,0 @@ -Adds the ability to call asynchronous functions and process with ease. See -the documentation for `async-start' and `async-start-process'. -- 2.47.3