python-environment-20150310.853.tar

python-environment-20150310.853/000755 000765 000024 00000000000 14024474445 017352 5ustar00duynguyenstaff000000 000000 python-environment-20150310.853/python-environment.el000644 000765 000024 00000022053 14024474444 023560 0ustar00duynguyenstaff000000 000000 ;;; python-environment.el --- virtualenv API for Emacs Lisp

;; Copyright (C) 2015 Takafumi Arakaki

;; Author: Takafumi Arakaki <aka.tkf at gmail.com>
;; Keywords: applications, tools
;; Version: 0.0.2
;; Package-Requires: ((deferred "0.3.1"))

;; This file is NOT part of GNU Emacs.

;; python-environment.el 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.

;; python-environment.el 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 python-environment.el.
;; If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;

;;; Code:

(require 'deferred)

(defconst python-environment-version "0.0.2alpha0")

(defcustom python-environment-directory
  (locate-user-emacs-file ".python-environments")
  "Path to directory to store all Python virtual environments.  A string.

If you want to change the location to, say ``~/.python-environments``,
then set it like this in your Emacs setup file::

    (setq python-environment-directory \"~/.python-environments\")"
  :group 'python-environment)

(defcustom python-environment-default-root-name "default"
  "Default Python virtual environment name.  A string.

This is a name of directory relative to `python-environment-directory'
where default virtual environment locates.
Thus, typically the default virtual environment path is
``~/.emacs.d/.python-environments/default``."
  :group 'python-environment)

(defcustom python-environment-virtualenv
  (list "virtualenv" "--system-site-packages" "--quiet")
  ;; --quiet is required for Windows.  Without it, virtualenv raises
  ;; UnicodeEncodeError
  ;; See: https://github.com/tkf/emacs-jedi/issues/148#issuecomment-38290546
  "``virtualenv`` command to use, including command options.  List of strings.

For example, if you want to use specific Python executable (to
specify Python version), append ``--python`` option like this::

    (setq python-environment-virtualenv
          (append python-environment-virtualenv
                  '(\"--python\" \"PATH/TO/bin/python\")))

I added ``--system-site-packages`` as default, but this is not
mandatory.  If you don't like it, removing does not break
anything (well, theoretically).  For reason why it is default,
see discussion here:
https://github.com/tkf/emacs-python-environment/issues/3"
  :group 'python-environment)

(defvar python-environment--verbose nil)

(defun python-environment--deferred-process (msg command)
  (message "%s..." msg)
  (deferred:$
    (apply #'deferred:process command)
    (deferred:watch it
      (apply-partially
       (lambda (msg output)
         (message "%s...Done" msg)
         (when python-environment--verbose
           (message output)))
       msg))))

(defun python-environment--blocking-process (msg command)
  (message "%s (SYNC)..." msg)
  (let (exit-code output)
    (with-temp-buffer
      (setq exit-code
            (apply #'call-process (car command)
                   nil                ; INFILE (no input)
                   t                  ; BUFFER (output to this buffer)
                   nil                ; DISPLAY (no refresh is needed)
                   (cdr command)))
      (setq output (buffer-string)))
    (when (or python-environment--verbose
              (not (= exit-code 0)))
      (message output))
    (message "%s (SYNC)...Done" msg)
    (unless (= exit-code 0)
      (error "Command %S exits with error code %S." command exit-code))))


(defun python-environment-root-path (&optional root)
  (expand-file-name (or root python-environment-default-root-name)
                    python-environment-directory))

(defun python-environment--make-with-runner (proc-runner root virtualenv)
  (let ((path (convert-standard-filename
               (python-environment-root-path root)))
        (virtualenv (append (or virtualenv python-environment-virtualenv)
                            (when python-environment--verbose
                              (list "--verbose")))))
    (unless (executable-find (car virtualenv))
      (error "Program named %S does not exist." (car virtualenv)))
    (funcall proc-runner
             (format "Making virtualenv at %s" path)
             (append virtualenv (list path)))))

(defun python-environment-make (&optional root virtualenv)
  "Make virtual environment at ROOT asynchronously.

This function does not wait until ``virtualenv`` finishes.
Instead, it returns a deferred object [#]_.  So, if you want to
do some operation after the ``virtualenv`` command finishes, do
something like this::

    (deferred:$
     (python-environment-make)
     (deferred:nextc it (lambda (output) DO-SOMETHING-HERE)))

If ROOT is specified, it is used instead of
`python-environment-default-root-name'.  ROOT can be a relative
path from `python-environment-virtualenv' or an absolute path.

If VIRTUALENV (list of string) is specified, it is used instead of
`python-environment-virtualenv'.

.. [#] https://github.com/kiwanami/emacs-deferred"
  (python-environment--make-with-runner
   #'python-environment--deferred-process
   root virtualenv))

(defun python-environment-make-block (&optional root virtualenv)
  "Blocking version of `python-environment-make'.
I recommend NOT to use this function in interactive commands.
For reason, see `python-environment-run-block'"
  (python-environment--make-with-runner
   #'python-environment--blocking-process
   root virtualenv))

(defun python-environment-exists-p (&optional root)
  "Return non-`nil' if virtualenv at ROOT exists.
See `python-environment-make' for how ROOT is interpreted."
  (let ((bin (python-environment-bin "python" root)))
    (and bin (file-exists-p bin))))

(defun python-environment--existing (root &rest paths)
  (when paths
    (let ((full-path (expand-file-name (car paths)
                                       (python-environment-root-path root))))
      (if (file-exists-p full-path)
          full-path
        (apply #'python-environment--existing root (cdr paths))))))

(defun python-environment-bin (path &optional root)
  "Return full path to \"ROOT/bin/PATH\" or \"ROOT/Scripts/PATH\" if exists.
``Scripts`` is used instead of ``bin`` in typical Windows case.
In Windows, path with extension \".ext\" may be returned.
See `python-environment-make' for how ROOT is interpreted."
  (python-environment--existing root
                                (concat "bin/" path)
                                (concat "Scripts/" path)
                                (concat "Scripts/" path ".exe")))

(defun python-environment-lib (path &optional root)
  "Return full path to \"ROOT/lib/PATH\" or \"ROOT/Lib/PATH\" if exists.
``Lib`` is used instead of ``lib`` in typical Windows case.
See `python-environment-make' for how ROOT is interpreted."
  (python-environment--existing root
                                (concat "lib/" path)
                                (concat "Lib/" path)))

(defun python-environment--run-with-runner (proc-runner command root)
  (funcall proc-runner
           (format "Running: %s" (mapconcat 'identity command " "))
           (cons (python-environment-bin (car command) root)
                 (cdr command))))

(defun python-environment--run-1 (&optional command root)
  (python-environment--run-with-runner
   #'python-environment--deferred-process
   command root))

(defun python-environment--run-block-1 (command root)
  (python-environment--run-with-runner
   #'python-environment--blocking-process
   command root))

(defun python-environment-run (command &optional root virtualenv)
  "Run COMMAND installed in Python virtualenv located at ROOT
asynchronously.

Instead of waiting for COMMAND to finish, a deferred object [#]_
is returned so that you can chain operations.

See `python-environment-make' for how ROOT and VIRTUALENV are
interpreted and how to work with deferred object.

Use `python-environment-run-block' if you want to wait until
the command exit (NOT recommended in interactive command).

.. [#] https://github.com/kiwanami/emacs-deferred"
  (if (python-environment-exists-p root)
      (python-environment--run-1 command root)
    (deferred:$
      (python-environment-make root virtualenv)
      (deferred:nextc it
        (apply-partially
         (lambda (command root _)
           (python-environment--run-1 command root))
         command root)))))

(defun python-environment-run-block (command &optional root virtualenv)
  "Blocking version of `python-environment-run'.
I recommend NOT to use this function in interactive commands.
Emacs users have more important things to than waiting for some
command to finish."
  (unless (python-environment-exists-p root)
    (python-environment-make-block root virtualenv))
  (python-environment--run-block-1 command root))

(provide 'python-environment)

;; Local Variables:
;; coding: utf-8
;; indent-tabs-mode: nil
;; End:

;;; python-environment.el ends here
python-environment-20150310.853/python-environment-pkg.el000644 000765 000024 00000000563 14024474444 024341 0ustar00duynguyenstaff000000 000000 (define-package "python-environment" "20150310.853" "virtualenv API for Emacs Lisp"
  '((deferred "0.3.1"))
  :commit "401006584e32864a10c69d29f14414828909362e" :authors
  '(("Takafumi Arakaki <aka.tkf at gmail.com>"))
  :maintainer
  '("Takafumi Arakaki <aka.tkf at gmail.com>")
  :keywords
  '("applications" "tools"))
;; Local Variables:
;; no-byte-compile: t
;; End:
python-environment-20150310.853/test-python-environment.el000644 000765 000024 00000016754 14024474444 024550 0ustar00duynguyenstaff000000 000000 ;;; test-python-environment.el --- Tests for python-environment.el

;; Copyright (C) 2013 Takafumi Arakaki

;; Author: Takafumi Arakaki <aka.tkf at gmail.com>

;; This file is NOT part of GNU Emacs.

;; test-python-environment.el 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.

;; test-python-environment.el 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 test-python-environment.el.
;; If not, see <http://www.gnu.org/licenses/>.

;;; Commentary:

;;

;;; Code:

(require 'ert)
(require 'python-environment)

(defmacro pye-test-with-temp-env (&rest body)
  (declare (debug (&rest form))
           (indent 0))
  (let ((path (make-symbol "path")))
    `(let* ((,path (make-temp-file "pye-test-" t))
            (python-environment-directory ,path))
       (unwind-protect
           (progn ,@body)
         (delete-directory ,path t)))))

(defmacro pye-deftest (name args &rest body)
  "Customized `ert-deftest'.  Bind `python-environment-directory' to a
temporary directory while executing BODY."
  (declare (debug (&define :name test
                           name sexp [&optional stringp]
                           [&rest keywordp sexp] def-body))
           (doc-string 3)
           (indent 2))
  `(ert-deftest ,name ,args
     (pye-test-with-temp-env
       ,@body)))

(defmacro pye-with-mixed-environment (environment &rest body)
  "Mix-in ENVIRONMENT to `process-environment' while executing `BODY'.
ENVIRONMENT is a list whose element is arguments (i.e., list) to `setenv'."
  (declare (debug (sexp &rest form))
           (indent 1))
  `(let ((process-environment (mapcar #'identity process-environment)))
     (mapc (lambda (env) (apply #'setenv env)) ,environment)
     ,@body))

(defun pye-eval-in-subprocess (sexp &optional environment)
  "Evaluate SEXP in Emacs launched as subprocess.  Additional environment
variable can be given as ENVIRONMENT (see `pye-with-mixed-environment')."
  (let ((default-directory (expand-file-name default-directory)))
    ;; Resolution of "~/" will be affected by `environment' if it
    ;; includes "$HOME".  So expand it before
    ;; `pye-with-mixed-environment' to avoid the confusion.
    (pye-with-mixed-environment environment
      (let ((print-length nil)
            (print-level nil))
        (with-temp-buffer
          (let ((code (call-process
                       (concat invocation-directory invocation-name)
                       nil t nil
                       "-Q" "--batch"
                       "--eval" (format "(setq load-path (cons %S '%S))"
                                        default-directory load-path)
                       "--load" (locate-library "test-python-environment")
                       "--eval" (format "%S" sexp))))
            (unless (eq code 0)
              (error "Subprocess terminated with code %S.\nOutput:\n%s"
                     code (buffer-string)))))))))

(defmacro pye-test-with-capture-message (&rest form)
  (declare (debug (&rest form))
           (indent 0))
  `(let ((start (make-marker))
         (message-buffer (get-buffer "*Messages*")))
     (with-current-buffer message-buffer
       (set-marker start (point-max)))
     (progn ,@form)
     (with-current-buffer message-buffer
       (buffer-substring start (point-max)))))

(ert-deftest pye-test-test-with-capture-message ()
  (should (equal (pye-test-with-capture-message
                   (message "test-1")
                   (message "test-2"))
                 "test-1\ntest-2\n")))

(defun pye-test-proc-runner-output-message (proc-runner desired-output)
  (let* ((command '("echo" "DUMMY-ECHO-MESSAGE"))
         (python-environment--verbose t)
         (message-output
          (pye-test-with-capture-message
            (funcall proc-runner "DUMMY-MESSAGE" command))))
    (should (equal message-output desired-output))))

(ert-deftest pye-test-deferred-process-output-message ()
  (pye-test-proc-runner-output-message
   (lambda (msg command)
     (deferred:sync! (python-environment--deferred-process msg command))) "\
DUMMY-MESSAGE...Done
DUMMY-ECHO-MESSAGE

"))

(ert-deftest pye-test-blocking-process-output-message ()
  (pye-test-proc-runner-output-message
   #'python-environment--blocking-process "\
DUMMY-MESSAGE (SYNC)...
DUMMY-ECHO-MESSAGE

DUMMY-MESSAGE (SYNC)...Done
"))

(defun pye-test-deferred-process-should-error ()
  (let (err)
    (deferred:sync!
      (deferred:error
        (python-environment--deferred-process
         "DUMMY-MESSAGE"
         '("false"))
        (lambda (got) (setq err got))))
    (should err)))

(ert-deftest pye-test-deferred-process-error-without-verbose ()
  (let ((python-environment--verbose nil))
    (pye-test-deferred-process-should-error)))

(ert-deftest pye-test-deferred-process-noerror-without-verbose ()
  (let ((python-environment--verbose nil))
    (deferred:sync!
      (python-environment--deferred-process "DUMMY-MESSAGE" '("true")))))

(ert-deftest pye-test-blocking-process-error-without-verbose ()
  (let ((python-environment--verbose nil))
    (should-error
     (python-environment--blocking-process "DUMMY-MESSAGE" '("false")))))

(ert-deftest pye-test-blocking-process-noerror-without-verbose ()
  (let ((python-environment--verbose nil))
    (python-environment--blocking-process "DUMMY-MESSAGE" '("true"))))

(ert-deftest pye-test-deferred-process-error-with-verbose ()
  (let ((python-environment--verbose t))
    (pye-test-deferred-process-should-error)))

(ert-deftest pye-test-deferred-process-noerror-with-verbose ()
  (let ((python-environment--verbose t))
    (deferred:sync!
      (python-environment--deferred-process "DUMMY-MESSAGE" '("true")))))

(ert-deftest pye-test-blocking-process-error-with-verbose ()
  (let ((python-environment--verbose t))
    (should-error
     (python-environment--blocking-process "DUMMY-MESSAGE" '("false")))))

(ert-deftest pye-test-blocking-process-noerror-with-verbose ()
  (let ((python-environment--verbose t))
    (python-environment--blocking-process "DUMMY-MESSAGE" '("true"))))

(pye-deftest pye-test-make-environment-with-non-existing-command ()
  (should-error (python-environment-make nil '("non-existing-command"))))

(pye-deftest pye-test-make-environment ()
  (deferred:sync! (python-environment-make)))

(pye-deftest pye-test-run ()
  (deferred:sync! (python-environment-run '("python" "--version"))))

(pye-deftest pye-test-run-block ()
  (python-environment-run-block '("python" "--version")))

(pye-deftest pye-test-block-error ()
  (should-error (python-environment-run-block '("python" "-c" "1/0"))))

(ert-deftest pye-test-eval-in-subprocess ()
  (pye-eval-in-subprocess '(+ 1 2))
  (should-error (pye-eval-in-subprocess '(error "some error"))))

(pye-deftest pye-test-bare-make-environment ()
  (let ((tmp-home python-environment-directory))
    (pye-eval-in-subprocess '(deferred:sync! (python-environment-make))
                            `(("HOME" ,tmp-home)))
    (should (file-directory-p (expand-file-name
                               ".emacs.d/.python-environments/default"
                               tmp-home)))))

(provide 'test-python-environment)

;; Local Variables:
;; coding: utf-8
;; indent-tabs-mode: nil
;; End:

;;; test-python-environment.el ends here
python-environment-20150310.853/python-environment-autoloads.el000644 000765 000024 00000001744 14024474444 025555 0ustar00duynguyenstaff000000 000000 ;;; python-environment-autoloads.el --- automatically extracted autoloads
;;
;;; Code:

(add-to-list 'load-path (directory-file-name
                         (or (file-name-directory #$) (car load-path))))


;;;### (autoloads nil "python-environment" "python-environment.el"
;;;;;;  (0 0 0 0))
;;; Generated autoloads from python-environment.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "python-environment" '("python-environment-")))

;;;***

;;;### (autoloads nil "test-python-environment" "test-python-environment.el"
;;;;;;  (0 0 0 0))
;;; Generated autoloads from test-python-environment.el

(if (fboundp 'register-definition-prefixes) (register-definition-prefixes "test-python-environment" '("pye-")))

;;;***

;;;### (autoloads nil nil ("python-environment-pkg.el") (0 0 0 0))

;;;***

;; Local Variables:
;; version-control: never
;; no-byte-compile: t
;; no-update-autoloads: t
;; coding: utf-8
;; End:
;;; python-environment-autoloads.el ends here