about summary refs log tree commit diff
path: root/configs/shared/emacs/.emacs.d/elpa/async-20180527.1730/async.el
diff options
context:
space:
mode:
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/async-20180527.1730/async.el')
-rw-r--r--configs/shared/emacs/.emacs.d/elpa/async-20180527.1730/async.el392
1 files changed, 0 insertions, 392 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/async-20180527.1730/async.el b/configs/shared/emacs/.emacs.d/elpa/async-20180527.1730/async.el
deleted file mode 100644
index 771e64105330..000000000000
--- a/configs/shared/emacs/.emacs.d/elpa/async-20180527.1730/async.el
+++ /dev/null
@@ -1,392 +0,0 @@
-;;; async.el --- Asynchronous processing in Emacs -*- lexical-binding: t -*-
-
-;; Copyright (C) 2012-2016 Free Software Foundation, Inc.
-
-;; Author: John Wiegley <jwiegley@gmail.com>
-;; Created: 18 Jun 2012
-;; Version: 1.9.3
-
-;; Keywords: async
-;; 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 2, or (at
-;; your option) any later version.
-
-;; This program is distributed in the hope that it will be useful, but
-;; WITHOUT ANY WARRANTY; without even the implied warranty of
-;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
-;; General Public License for more details.
-
-;; You should have received a copy of the GNU General Public License
-;; along with GNU Emacs; see the file COPYING.  If not, write to the
-;; Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-;; Boston, MA 02111-1307, USA.
-
-;;; Commentary:
-
-;; Adds the ability to call asynchronous functions and process with ease.  See
-;; the documentation for `async-start' and `async-start-process'.
-
-;;; Code:
-
-(eval-when-compile (require 'cl-lib))
-
-(defgroup async nil
-  "Simple asynchronous processing in Emacs"
-  :group 'emacs)
-
-(defcustom async-variables-noprops-function #'async-variables-noprops
-  "Default function to remove text properties in variables."
-  :group 'async
-  :type 'function)
-
-(defvar async-debug nil)
-(defvar async-send-over-pipe t)
-(defvar async-in-child-emacs nil)
-(defvar async-callback nil)
-(defvar async-callback-for-process nil)
-(defvar async-callback-value nil)
-(defvar async-callback-value-set nil)
-(defvar async-current-process nil)
-(defvar async--procvar nil)
-
-(defun async-variables-noprops (sequence)
-  "Remove text properties in SEQUENCE.
-
-Argument SEQUENCE may be a list or a string, if anything else it
-is returned unmodified.
-
-Note that this is a naive function that doesn't remove text properties
-in SEQUENCE recursively, only at the first level which suffice in most
-cases."
-  (cond ((stringp sequence)
-         (substring-no-properties sequence))
-        ((listp sequence)
-         (cl-loop for elm in sequence
-                  if (stringp elm)
-                  collect (substring-no-properties elm)
-                  else collect elm))
-        (t sequence)))
-
-(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\".
-When NOPROPS is non nil it tries to strip out text properties of each
-variable's value with `async-variables-noprops-function'.
-
-It is intended to be used as follows:
-
-    (async-start
-       `(lambda ()
-          (require 'smtpmail)
-          (with-temp-buffer
-            (insert ,(buffer-substring-no-properties (point-min) (point-max)))
-            ;; Pass in the variable environment for smtpmail
-            ,(async-inject-variables \"\\`\\(smtpmail\\|\\(user-\\)?mail\\)-\")
-            (smtpmail-send-it)))
-       'ignore)"
-  `(setq
-    ,@(let (bindings)
-        (mapatoms
-         (lambda (sym)
-           (let* ((sname (and (boundp sym) (symbol-name sym)))
-                  (value (and sname (symbol-value sym))))
-             (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)))
-               (unless (or (stringp value)
-                           (memq value '(nil t))
-                           (numberp value)
-                           (vectorp value))
-                 (setq value `(quote ,value)))
-               (when noprops
-                 (setq value (funcall async-variables-noprops-function
-                                      value)))
-               (when (or (null predicate)
-                         (funcall predicate sym))
-                 (setq bindings (cons value bindings)
-                       bindings (cons sym bindings)))))))
-        bindings)))
-
-(defalias 'async-inject-environment 'async-inject-variables)
-
-(defun async-handle-result (func result buf)
-  (if (null func)
-      (progn
-        (set (make-local-variable 'async-callback-value) result)
-        (set (make-local-variable 'async-callback-value-set) t))
-    (unwind-protect
-        (if (and (listp result)
-                 (eq 'async-signal (nth 0 result)))
-            (signal (car (nth 1 result))
-                    (cdr (nth 1 result)))
-          (funcall func result))
-      (unless async-debug
-        (kill-buffer buf)))))
-
-(defun async-when-done (proc &optional _change)
-  "Process sentinel used to retrieve the value from the child process."
-  (when (eq 'exit (process-status proc))
-    (with-current-buffer (process-buffer proc)
-      (let ((async-current-process proc))
-        (if (= 0 (process-exit-status proc))
-            (if async-callback-for-process
-                (if async-callback
-                    (prog1
-                        (funcall async-callback proc)
-                      (unless async-debug
-                        (kill-buffer (current-buffer))))
-                  (set (make-local-variable 'async-callback-value) proc)
-                  (set (make-local-variable 'async-callback-value-set) t))
-              (goto-char (point-max))
-              (backward-sexp)
-              (async-handle-result async-callback (read (current-buffer))
-                                   (current-buffer)))
-          (set (make-local-variable 'async-callback-value)
-               (list 'error
-                     (format "Async process '%s' failed with exit code %d"
-                             (process-name proc) (process-exit-status proc))))
-          (set (make-local-variable 'async-callback-value-set) t))))))
-
-(defun async--receive-sexp (&optional stream)
-  (let ((sexp (decode-coding-string (base64-decode-string
-                                     (read stream)) 'utf-8-auto))
-	;; Parent expects UTF-8 encoded text.
-	(coding-system-for-write 'utf-8-auto))
-    (if async-debug
-        (message "Received sexp {{{%s}}}" (pp-to-string sexp)))
-    (setq sexp (read sexp))
-    (if async-debug
-        (message "Read sexp {{{%s}}}" (pp-to-string sexp)))
-    (eval sexp)))
-
-(defun async--insert-sexp (sexp)
-  (let (print-level
-	print-length
-	(print-escape-nonascii t)
-	(print-circle t))
-    (prin1 sexp (current-buffer))
-    ;; Just in case the string we're sending might contain EOF
-    (encode-coding-region (point-min) (point-max) 'utf-8-auto)
-    (base64-encode-region (point-min) (point-max) t)
-    (goto-char (point-min)) (insert ?\")
-    (goto-char (point-max)) (insert ?\" ?\n)))
-
-(defun async--transmit-sexp (process sexp)
-  (with-temp-buffer
-    (if async-debug
-        (message "Transmitting sexp {{{%s}}}" (pp-to-string sexp)))
-    (async--insert-sexp sexp)
-    (process-send-region process (point-min) (point-max))))
-
-(defun async-batch-invoke ()
-  "Called from the child Emacs process' command-line."
-  ;; Make sure 'message' and 'prin1' encode stuff in UTF-8, as parent
-  ;; process expects.
-  (let ((coding-system-for-write 'utf-8-auto))
-    (setq async-in-child-emacs t
-	  debug-on-error async-debug)
-    (if debug-on-error
-	(prin1 (funcall
-		(async--receive-sexp (unless async-send-over-pipe
-				       command-line-args-left))))
-      (condition-case err
-	  (prin1 (funcall
-		  (async--receive-sexp (unless async-send-over-pipe
-					 command-line-args-left))))
-	(error
-	 (prin1 (list 'async-signal err)))))))
-
-(defun async-ready (future)
-  "Query a FUTURE to see if it is ready.
-
-I.e., if no blocking
-would result from a call to `async-get' on that FUTURE."
-  (and (memq (process-status future) '(exit signal))
-       (let ((buf (process-buffer future)))
-         (if (buffer-live-p buf)
-             (with-current-buffer buf
-               async-callback-value-set)
-             t))))
-
-(defun async-wait (future)
-  "Wait for FUTURE to become ready."
-  (while (not (async-ready future))
-    (sleep-for 0.05)))
-
-(defun async-get (future)
-  "Get the value from process FUTURE when it is ready.
-FUTURE is returned by `async-start' or `async-start-process' when
-its FINISH-FUNC is nil."
-  (and future (async-wait future))
-  (let ((buf (process-buffer future)))
-    (when (buffer-live-p buf)
-      (with-current-buffer buf
-        (async-handle-result
-         #'identity async-callback-value (current-buffer))))))
-
-(defun async-message-p (value)
-  "Return true of VALUE is an async.el message packet."
-  (and (listp value)
-       (plist-get value :async-message)))
-
-(defun async-send (&rest args)
-  "Send the given messages to the asychronous Emacs PROCESS."
-  (let ((args (append args '(:async-message t))))
-    (if async-in-child-emacs
-        (if async-callback
-            (funcall async-callback args))
-      (async--transmit-sexp (car args) (list 'quote (cdr args))))))
-
-(defun async-receive ()
-  "Send the given messages to the asychronous Emacs PROCESS."
-  (async--receive-sexp))
-
-;;;###autoload
-(defun async-start-process (name program finish-func &rest program-args)
-  "Start the executable PROGRAM asynchronously.  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."
-  (let* ((buf (generate-new-buffer (concat "*" name "*")))
-         (proc (let ((process-connection-type nil))
-                 (apply #'start-process name buf program program-args))))
-    (with-current-buffer buf
-      (set (make-local-variable 'async-callback) finish-func)
-      (set-process-sentinel proc #'async-when-done)
-      (unless (string= name "emacs")
-        (set (make-local-variable 'async-callback-for-process) t))
-      proc)))
-
-(defvar async-quiet-switch "-Q"
-  "The Emacs parameter to use to call emacs without config.
-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.")
-
-;;;###autoload
-(defun async-start (start-func &optional finish-func)
-  "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 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)
-
-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'."
-  (let ((sexp start-func)
-	;; Subordinate Emacs will send text encoded in UTF-8.
-	(coding-system-for-read 'utf-8-auto))
-    (setq async--procvar
-          (async-start-process
-           "emacs" (file-truename
-                    (expand-file-name invocation-name
-                                      invocation-directory))
-           finish-func
-           async-quiet-switch "-l"
-           ;; Using `locate-library' ensure we use the right file
-           ;; when the .elc have been deleted.
-           (locate-library "async")
-           "-batch" "-f" "async-batch-invoke"
-           (if async-send-over-pipe
-               "<none>"
-               (with-temp-buffer
-                 (async--insert-sexp (list 'quote sexp))
-                 (buffer-string)))))
-    (if async-send-over-pipe
-        (async--transmit-sexp async--procvar (list 'quote sexp)))
-    async--procvar))
-
-(defmacro async-sandbox(func)
-  "Evaluate FUNC in a separate Emacs process, synchronously."
-  `(async-get (async-start ,func)))
-
-(defun async--fold-left (fn forms bindings)
-  (let ((res forms))
-    (dolist (binding bindings)
-      (setq res (funcall fn res
-                         (if (listp binding)
-                             binding
-                             (list binding)))))
-    res))
-
-(defmacro async-let (bindings &rest forms)
-  "Implements `let', but each binding is established asynchronously.
-For example:
-
-  (async-let ((x (foo))
-              (y (bar)))
-     (message \"%s %s\" x y))
-
-    expands to ==>
-
-  (async-start (foo)
-   (lambda (x)
-     (async-start (bar)
-      (lambda (y)
-        (message \"%s %s\" x y)))))"
-  (declare (indent 1))
-  (async--fold-left
-   (lambda (acc binding)
-     (let ((fun (pcase (cadr binding)
-                  ((and (pred functionp) f) f)
-                  (f `(lambda () ,f)))))
-       `(async-start ,fun
-                     (lambda (,(car binding))
-                       ,acc))))
-   `(progn ,@forms)
-   (reverse bindings)))
-
-(provide 'async)
-
-;;; async.el ends here