You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
429 lines
16 KiB
429 lines
16 KiB
;;; virtualenv.el --- Virtualenv for Python -*- coding: utf-8 -*-
|
|
|
|
;; Copyright (c) 2010-2012 Aaron Culich
|
|
|
|
;; Author: Aaron Culich <aculich@gmail.com>
|
|
;; Maintainer: Aaron Culich <aculich@gmail.com>
|
|
;; Version: 1.2
|
|
;; Created: September 2010
|
|
;; Updated: September 2012
|
|
;; Keywords: python virtualenv
|
|
;; Vcs-git: git://github.com/aculich/virtualenv.git
|
|
;; Vcs-Browser: http://github.com/aculich/virtualenv
|
|
|
|
;; virtualenv.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.
|
|
;;
|
|
;; virtualenv.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 virtualenv.el. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
;;; Commentary:
|
|
|
|
;; This is a minor mode for setting the virtual environment for the
|
|
;; Python shell using virtualenv and supports both python-mode.el and
|
|
;; python.el. This minor mode was inspired by an earlier
|
|
;; implementation by Jesse Legg and Jeremiah Dodds, however this code
|
|
;; is a complete re-write with a GPLv3 license consistent with
|
|
;; GNU Emacs and python-mode.el.
|
|
|
|
;; There are two ways to use virtualenv.
|
|
|
|
;; 1) The quickest way to get started is to simply type:
|
|
;; M-x virtualenv-workon
|
|
;; Which will prompt you to enter the name of a directory in
|
|
;; ~/.virtualenvs that contains your chosen environment. You can
|
|
;; hit tab to show the available completions.
|
|
|
|
;; You'll know that you're in virtualenv mode now when you see the
|
|
;; name of the virtualenv you selected in brackets. So if I were to
|
|
;; select my turbogears environment that I call tg2.1 then I would
|
|
;; see [tg2.1] appear in the mode line. To make sure you're new
|
|
;; python shell is set up correctly you can try running this little
|
|
;; snippet of python code:
|
|
|
|
;; import os, sys
|
|
;; print os.environ
|
|
;; print sys.path
|
|
|
|
;; 2) The recommended way to use virtualenv minor mode is to use a
|
|
;; .dir-locals.el file in the root of your project directory, however that
|
|
;; requires Emacs 23.1 or higher. There are two buffer-local variables that you
|
|
;; can set for virtualenv as shown in this example:
|
|
|
|
;; in file /path/to/project/.dir-locals.el:
|
|
;; ((nil . ((virtualenv-workon . "tg2.1")
|
|
;; (virtualenv-default-directory . "/path/to/project/subdir"))))
|
|
|
|
;; The .dir-locals.el is new in Emacs23 and is useful for other
|
|
;; things, too. You should read the dir-locals docs to understand the
|
|
;; format. The variable virtualenv-workon should just be a string the
|
|
;; same as you'd give to the interactive function. The variable
|
|
;; virtualenv-default-directory is useful when you want to have your
|
|
;; python process rooted in a particular directory when it starts, so
|
|
;; that no matter where you are in your project's hierarchy, if you
|
|
;; launch a python shell. This method is recommended because it is
|
|
;; more flexible and will allow multiple virtualenvs running at once
|
|
;; in future versions.
|
|
|
|
;;; Bugs:
|
|
|
|
;; All bug reports can be filed by opening a new issue on github at:
|
|
;; http://github.com/aculich/virtualenv/issues
|
|
|
|
;;; TODO:
|
|
|
|
;; * support for multiple python processes in different virtualenvs
|
|
|
|
;; * add "paster shell" features
|
|
|
|
;; * add support for shell-command
|
|
|
|
;;; Code:
|
|
|
|
(defgroup virtualenv nil
|
|
"Emacs support for python virtualenv."
|
|
:group 'python)
|
|
|
|
(defcustom virtualenv-root
|
|
(or (getenv "WORKON_HOME") "~/.virtualenvs")
|
|
"Default location for user's virtual environments"
|
|
:group 'virtualenv
|
|
:type 'directory)
|
|
|
|
(defcustom virtualenv-mode-string-format " [%s]"
|
|
"Format for the mode string. It should start with a space."
|
|
:group 'virtualenv
|
|
:type 'string)
|
|
|
|
(defcustom virtualenv-workon-starts-python t
|
|
"If non-nil the `virtualenv-workon' will also start python."
|
|
:group 'virtualenv
|
|
:type 'boolean)
|
|
|
|
(defvar virtualenv-mode-name-default " Virtualenv"
|
|
"The default name in the mode line in case `virtualenv-workon' is not set.
|
|
In practice you should never see this in the mode line, but it is
|
|
better to use this than for it to appear blank.")
|
|
|
|
(defvar virtualenv-mode-name virtualenv-mode-name-default)
|
|
|
|
(defvar virtualenv-executables-dir
|
|
(if (eq system-type 'windows-nt) "/Scripts" "/bin")
|
|
"The name of the directory containing executables. It is system
|
|
dependent.")
|
|
|
|
(defvar virtualenv-default-directory nil
|
|
"Buffer-local variable that should be set in your project's
|
|
top-level .dir-locals.el file as the place you want to start the python shell.
|
|
When using paster set this to where your .ini files live, e.g.: \
|
|
((nil . ((virtualenv-default-directory . \"/projects/foo\"))))")
|
|
(put 'virtualenv-default-directory 'safe-local-variable 'stringp)
|
|
|
|
(defvar virtualenv-workon nil
|
|
"Buffer-local variable that should be set in your project's
|
|
top-level .dir-locals.el file, e.g.: \
|
|
((nil . ((virtualenv-workon . \"tg2.1\"))))")
|
|
(put 'virtualenv-workon 'safe-local-variable 'stringp)
|
|
|
|
(defvar virtualenv-workon-session nil
|
|
"The virtualenv that this emacs session will workon.")
|
|
(put 'virtualenv-default-directory 'risky-local-variable 'stringp)
|
|
|
|
(defvar virtualenv-workon-history nil
|
|
"History list of virtual environments used.")
|
|
|
|
(defvar virtualenv-saved-path nil
|
|
"Saves `exec-path' and the `PATH' environment variable when
|
|
invoking `virtualenv-workon'.")
|
|
|
|
(defun virtualenv-formatted-mode-string (&optional name)
|
|
"Format the `virtualenv-mode-name' string.
|
|
Optional argument NAME is a string that will appear as [NAME] in
|
|
the mode line, however if NAME begins with a space the string
|
|
will be used verbatim. If NAME is nil and `virtualenv-workon' is
|
|
not set, then use `virtualenv-mode-name-default'."
|
|
(let* ((name (or name
|
|
virtualenv-workon-session
|
|
virtualenv-workon
|
|
virtualenv-mode-name-default)))
|
|
(if (string= " " (substring name 0 1))
|
|
name
|
|
(format virtualenv-mode-string-format name))))
|
|
|
|
(defun virtualenv-update-mode-name (&optional name)
|
|
"Update the mode line with a string formatted for virtualenv.
|
|
Optional argument NAME is a string that will appear as [NAME] in
|
|
the mode line, however if NAME begins with a space the string
|
|
will be used verbatim. If NAME is nil and `virtualenv-workon' is
|
|
not set, then use `virtualenv-mode-name-default'."
|
|
(let ((string (virtualenv-formatted-mode-string name)))
|
|
(make-local-variable 'virtualenv-mode-name)
|
|
(setq virtualenv-mode-name string)))
|
|
|
|
(defalias 'virtualenv-old-hack-dir-local-variables (symbol-function 'hack-dir-local-variables))
|
|
|
|
;;;###autoload
|
|
(defun virtualenv-workon (&optional env)
|
|
"Activate a virtual environment for python.
|
|
Optional argument ENV if non-nil, either use the string given as
|
|
the virtual environment or if not a string then query the user."
|
|
(interactive "P")
|
|
|
|
;; reset virtualenv-workon-session if env is non-nil and also not a
|
|
;; string (e.g. invoked interactively with C-u prefix arg)
|
|
(when (and env (not (stringp env)))
|
|
(setq virtualenv-workon-session nil))
|
|
|
|
(defalias 'hack-dir-local-variables 'virtualenv-hack-dir-local-variables)
|
|
|
|
;; if env is a string, then just use it, otherwise check to see if
|
|
;; we have already queried the user the session, at last querying
|
|
;; the user if all else fails.
|
|
(let ((env
|
|
(cond
|
|
((stringp env) env)
|
|
((stringp virtualenv-workon-session)
|
|
virtualenv-workon-session)
|
|
(t
|
|
(let* ((default (car virtualenv-workon-history))
|
|
(root (or (unless (file-directory-p virtualenv-root)
|
|
(let ((dir (read-directory-name
|
|
"Virtualenv Directory: "
|
|
(expand-file-name "~"))))
|
|
(funcall
|
|
(if (y-or-n-p
|
|
(format
|
|
"Save %s as virtualenv-root for future sessions?"
|
|
dir))
|
|
'customize-save-variable
|
|
'customize-set-variable)
|
|
'virtualenv-root
|
|
dir)))
|
|
virtualenv-root))
|
|
(prompt (concat
|
|
"Virtualenv to activate"
|
|
(when default
|
|
(format " (default %s)" default))
|
|
": "))
|
|
;; look for directories in virtualenv-root that
|
|
;; contain a bin directory for tab-completion
|
|
(dirs (remove
|
|
nil
|
|
(mapcar
|
|
(lambda (d)
|
|
(when (file-exists-p
|
|
(expand-file-name
|
|
(concat d virtualenv-executables-dir)
|
|
root))
|
|
d))
|
|
(directory-files root nil "^[^.]"))))
|
|
(result (completing-read prompt dirs nil t nil
|
|
'virtualenv-workon-history
|
|
default)))
|
|
|
|
;; if the user entered nothing, then return the default
|
|
;; if there is one
|
|
(if (not (string= result ""))
|
|
result
|
|
default))))))
|
|
|
|
(let* ((buffer (get-buffer "*Python*"))
|
|
(kill (or (when buffer
|
|
(yes-or-no-p
|
|
"Python process already running. Kill? ")))))
|
|
|
|
(if (or (not buffer) kill)
|
|
(progn
|
|
(when buffer
|
|
(kill-buffer buffer))
|
|
(setq virtualenv-workon-session env)
|
|
(let* ((bin (expand-file-name
|
|
(concat env virtualenv-executables-dir)
|
|
virtualenv-root))
|
|
(oldpath (or (car virtualenv-saved-path)
|
|
(getenv "PATH")))
|
|
(oldexec (or (cdr virtualenv-saved-path)
|
|
exec-path)))
|
|
(setq virtualenv-saved-path (cons oldpath oldexec))
|
|
(add-to-list 'exec-path bin)
|
|
(setenv "PATH"
|
|
(if (eq system-type 'windows-nt)
|
|
(concat bin path-separator
|
|
(replace-regexp-in-string
|
|
(regexp-quote "/") "\\" oldpath))
|
|
(concat bin path-separator oldpath))))
|
|
(when virtualenv-workon-starts-python
|
|
(cond ((fboundp 'python-shell-switch-to-shell)
|
|
(python-shell-switch-to-shell))
|
|
((fboundp 'py-shell)
|
|
(py-shell))
|
|
((fboundp 'python-shell)
|
|
(python-shell))
|
|
((fboundp 'run-python)
|
|
(run-python))
|
|
(t (error "Could not start a python shell!"))))
|
|
(message (format "Now using virtualenv: %s" env)))
|
|
(message "Not changing virtualenv")))))
|
|
|
|
;;;###autoload
|
|
(defun virtualenv-deactivate ()
|
|
(interactive)
|
|
|
|
(defalias 'hack-dir-local-variables (symbol-function 'virtualenv-old-hack-dir-local-variables))
|
|
|
|
(when virtualenv-saved-path
|
|
(setenv "PATH" (car virtualenv-saved-path))
|
|
(setq exec-path (cdr virtualenv-saved-path)))
|
|
|
|
(setq virtualenv-workon-session nil
|
|
virtualenv-saved-path nil)
|
|
(virtualenv-minor-mode 0))
|
|
|
|
;;;###autoload
|
|
(define-minor-mode virtualenv-minor-mode
|
|
nil ; use default docstring
|
|
nil ; the initial value
|
|
virtualenv-mode-name ; mode line indicator
|
|
nil ; keymap
|
|
:group 'virtualenv) ; group
|
|
|
|
(defun virtualenv-minor-mode-on ()
|
|
(interactive)
|
|
(when (or virtualenv-workon-session
|
|
virtualenv-workon)
|
|
(virtualenv-minor-mode t)))
|
|
|
|
(add-hook 'virtualenv-minor-mode-hook 'virtualenv-update-mode-name)
|
|
(add-hook 'find-file-hook 'virtualenv-minor-mode-on t)
|
|
|
|
;; This provides support for both python-mode.el and python.el by
|
|
;; adding defadvice to py-shell and python-shell.
|
|
(dolist (list '((python-shell-switch-to-shell . "python")
|
|
(py-shell . "python-mode")
|
|
(python-shell . "python")
|
|
(run-python . "python")))
|
|
(let* ((func (car list))
|
|
(file (cdr list))
|
|
(doc (format "Set the environment with virtualenv before running %s." func)))
|
|
|
|
(eval-after-load file
|
|
`(progn
|
|
|
|
(defadvice ,func (around virtualenv activate)
|
|
,doc
|
|
(let ((workon (or virtualenv-workon-session
|
|
virtualenv-workon)))
|
|
(if workon
|
|
(progn
|
|
(when (stringp virtualenv-default-directory)
|
|
(cd virtualenv-default-directory))
|
|
(let* ((activate (expand-file-name
|
|
"activate"
|
|
(expand-file-name
|
|
(concat workon virtualenv-executables-dir)
|
|
virtualenv-root)))
|
|
(process-environment
|
|
(when (file-exists-p activate)
|
|
(split-string
|
|
(shell-command-to-string
|
|
(if (eq system-type 'windows-nt)
|
|
(format "call %s & cd %s && set"
|
|
activate default-directory)
|
|
(format "source %s; (cd %s && env)"
|
|
activate default-directory)))
|
|
"\n")))
|
|
(exec-path (split-string (getenv "PATH") path-separator)))
|
|
ad-do-it
|
|
(hack-local-variables)
|
|
(virtualenv-minor-mode-on)
|
|
))
|
|
ad-do-it)))
|
|
|
|
|
|
))))
|
|
|
|
|
|
;; This is a hack on top of a hack, but it's the way I think dir-local
|
|
;; variables should work. The original implementation only loads
|
|
;; dir-locals if the buffer has a filename associated with it, however
|
|
;; for a python comint buffer or for dired, a call to
|
|
;; (buffer-file-name) returns nil. In that case we should use the
|
|
;; value of default-directory to check for the presence of
|
|
;; .dir-locals.el. This should actually have no effect on any existing
|
|
;; code because this hack-local-variables is only added to the
|
|
;; find-file-hook, so we can selectively enable this for other buffers
|
|
;; that we create, like python shells or dired.
|
|
|
|
(defcustom virtualenv-enable-local-variables :all
|
|
"Defaults to :all and allows `virtualenv-hack-dir-local-variables'
|
|
to override the value of `enable-local-variables' for convenience when
|
|
`virtualenv-workon' is enabled."
|
|
:risky t
|
|
:type '(choice (const :tag "Query Unsafe" t)
|
|
(const :tag "Safe Only" :safe)
|
|
(const :tag "Do all" :all)
|
|
(const :tag "Use value of `enable-local-variables'" nil)
|
|
(other :tag "Query" other))
|
|
:group 'virtualenv)
|
|
|
|
(defun virtualenv-hack-dir-local-variables ()
|
|
"Read per-directory local variables for the current buffer.
|
|
Store the directory-local variables in `dir-local-variables-alist'
|
|
and `file-local-variables-alist', without applying them."
|
|
(let ((path (or (buffer-file-name)
|
|
default-directory)))
|
|
(when (and (or virtualenv-enable-local-variables
|
|
enable-local-variables)
|
|
path
|
|
(not (file-remote-p path)))
|
|
;; Find the variables file.
|
|
(let ((variables-file (dir-locals-find-file path))
|
|
(class nil)
|
|
(dir-name nil))
|
|
(cond
|
|
((stringp variables-file)
|
|
(setq dir-name (file-name-directory path))
|
|
(setq class (dir-locals-read-from-file variables-file)))
|
|
((consp variables-file)
|
|
(setq dir-name (nth 0 variables-file))
|
|
(setq class (nth 1 variables-file))))
|
|
(when class
|
|
(let ((variables
|
|
(dir-locals-collect-variables
|
|
(dir-locals-get-class-variables class) dir-name nil)))
|
|
(when variables
|
|
(dolist (elt variables)
|
|
(unless (memq (car elt) '(eval mode))
|
|
(setq dir-local-variables-alist
|
|
(assq-delete-all (car elt) dir-local-variables-alist)))
|
|
(push elt dir-local-variables-alist))
|
|
;; override enable-local-variables with
|
|
;; virtualenv-enable-local-variables if set
|
|
(let ((enable-local-variables
|
|
(or virtualenv-enable-local-variables
|
|
enable-local-variables)))
|
|
(hack-local-variables-filter variables dir-name)))))))))
|
|
|
|
(defvar virtualenv-dir-local-not-supported
|
|
(cond ((featurep 'xemacs)
|
|
"XEmacs is not officially supported.")
|
|
((not (and (>= emacs-major-version 23)
|
|
(>= emacs-minor-version 1)))
|
|
"Emacs 23.1 is required for .dir-locals.el support.")))
|
|
|
|
(eval-after-load "dired"
|
|
'(progn
|
|
(unless virtualenv-dir-local-not-supported
|
|
(add-hook 'dired-mode-hook 'hack-local-variables))
|
|
(add-hook 'dired-mode-hook 'virtualenv-minor-mode-on t)))
|
|
|
|
(provide 'virtualenv)
|
|
|
|
;;; virtualenv.el ends here
|