[config.git] / djavu-asus / elpa / elpy-20230803.1455 / elpy-django.el

;;; elpy-django.el --- Django extension for elpy

;; Copyright (C) 2013-2019  Jorgen Schaefer

;; Author: Daniel Gopar <gopardaniel@gmail.com>
;; URL: https://github.com/jorgenschaefer/elpy

;; 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 <http://www.gnu.org/licenses/>.

;;; Commentary:

;; This file serves as an extension to elpy by adding django support

;;; Code:

(require 's)

;;;;;;;;;;;;;;;;;;;;;;
;;; User customization

(defcustom elpy-django-command "django-admin.py"
  "Command to use when running Django specific commands.
Best to set it to full path to 'manage.py' if it's available."
  :type 'string
  :safe 'stringp
  :group 'elpy-django)
(make-variable-buffer-local 'elpy-django-command)

(defcustom elpy-django-server-ipaddr "127.0.0.1"
  "What address Django will use when running the dev server."
  :type 'string
  :safe 'stringp
  :group 'elpy-django)
(make-variable-buffer-local 'elpy-django-server-ipaddr)

(defcustom elpy-django-server-port "8000"
  "What port Django will use when running the dev server."
  :type 'string
  :safe 'stringp
  :group 'elpy-django)
(make-variable-buffer-local 'elpy-django-server-port)

(defcustom elpy-django-server-command "runserver"
  "When executing `elpy-django-runserver' what should be the server
command to use."
  :type 'string
  :safe 'stringp
  :group 'elpy-django)
(make-variable-buffer-local 'elpy-django-server-command)

(defcustom elpy-django-always-prompt nil
  "When non-nil, it will always prompt for extra arguments
to pass with the chosen command."
  :type 'boolean
  :safe 'booleanp
  :group 'elpy-django)
(make-variable-buffer-local 'elpy-django-always-prompt)

(defcustom elpy-django-commands-with-req-arg '("startapp" "startproject"
                                               "loaddata" "sqlmigrate"
                                               "sqlsequencereset"
                                               "squashmigrations")
  "Used to determine if we should prompt for arguments. Some commands
require arguments in order for it to work."
  :type 'list
  :safe 'listp
  :group 'elpy-django)
(make-variable-buffer-local 'elpy-django-commands-with-req-arg)

(defcustom elpy-django-test-runner-formats '(("django_nose.NoseTestSuiteRunner" . ":")
                                             (".*" . "."))
  "List of test runners and their format for calling tests.

  The keys are the regular expressions to match the runner used in test,
while the values are the separators to use to build test target path.
Some tests runners are called differently. For example, Nose requires a ':' when calling specific tests,
but the default Django test runner uses '.'"
  :type 'list
  :safe 'listp
  :group 'elpy-django)
(make-variable-buffer-local 'elpy-django-test-runner-formats)

(defcustom elpy-django-test-runner-args '("test" "--noinput")
  "Arguments to pass to the test runner when calling tests."
  :type '(repeat string)
  :group 'elpy-django)
(make-variable-buffer-local 'elpy-django-test-runner-args)

(defcustom elpy-test-django-runner-command nil
  "Deprecated. Please define Django command in `elpy-django-command' and
test arguments in `elpy-django-test-runner-args'"
  :type '(repeat string)
  :group 'elpy-django)
(make-obsolete-variable 'elpy-test-django-runner-command nil "March 2018")

(defcustom elpy-test-django-runner-manage-command nil
  "Deprecated. Please define Django command in `elpy-django-command' and
test arguments in `elpy-django-test-runner-args'."
  :type '(repeat string)
  :group 'elpy-django)
(make-obsolete-variable 'elpy-test-django-runner-manage-command nil "March 2018")

(defcustom elpy-test-django-with-manage nil
  "Deprecated.  Please define Django command in `elpy-django-command' and
test arguments in `elpy-django-test-runner-args'."
  :type 'boolean
  :group 'elpy-django)
(make-obsolete-variable 'elpy-test-django-with-manage nil "March 2018")

;;;;;;;;;;;;;;;;;;;;;;
;; Key map

(defvar elpy-django-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "c") 'elpy-django-command)
    (define-key map (kbd "r") 'elpy-django-runserver)
    map)
  "Key map for django extension")

;;;;;;;;;;;;;;;;;;;;;;
;;; Helper Functions

(defun elpy-django-setup ()
  "Decides whether to start the minor mode or not."
  ;; Make sure we're in an actual file and we can find
  ;; manage.py. Otherwise user will have to manually
  ;; start this mode if they're using 'django-admin.py'
  (when (locate-dominating-file default-directory "manage.py")
    ;; Let's be nice and point to full path of 'manage.py'
    ;; This only affects the buffer if there's no directory
    ;; variable overwriting it.
    (setq elpy-django-command
          (expand-file-name (concat (locate-dominating-file default-directory "manage.py") "manage.py")))
    (elpy-django 1)))

(defun elpy-project-find-django-root ()
  "Return the current Django project root, if any.

This is marked with 'manage.py' or 'django-admin.py'."
  (or (locate-dominating-file default-directory "django-admin.py")
      (locate-dominating-file default-directory "manage.py")))

(defun elpy-django--get-commands ()
  "Return list of django commands."
  (let ((dj-commands-str nil)
        (help-output
         (shell-command-to-string (concat elpy-django-command " -h"))))
    (setq dj-commands-str
          (with-temp-buffer
            (progn
              (insert help-output)
              (goto-char (point-min))
              (delete-region (point) (search-forward "Available subcommands:" nil nil nil))
              ;; cleanup [auth] and stuff
              (goto-char (point-min))
              (save-excursion
                (while (re-search-forward "\\[.*\\]" nil t)
                  (replace-match "" nil nil)))
              (buffer-string))))
    ;; get a list of commands from the output of manage.py -h
    ;; What would be the pattern to optimize this ?
    (setq dj-commands-str (split-string dj-commands-str "\n"))
    (setq dj-commands-str (cl-remove-if (lambda (x) (string= x "")) dj-commands-str))
    (setq dj-commands-str (mapcar (lambda (x) (s-trim x)) dj-commands-str))
    (sort dj-commands-str 'string-lessp)))


(defvar elpy-django--test-runner-cache nil
  "Internal cache for elpy-django--get-test-runner.
The cache is keyed on project root and DJANGO_SETTINGS_MODULE env var")

(defvar elpy-django--test-runner-cache-max-size 100
  "Maximum number of entries in test runner cache")


(defun elpy-django--get-test-runner ()
  "Return the name of the django test runner.
Needs `DJANGO_SETTINGS_MODULE' to be set in order to work.
The result is memoized on project root and `DJANGO_SETTINGS_MODULE'"
  (let ((django-import-cmd "import django;django.setup();from django.conf import settings;print(settings.TEST_RUNNER)")
        (django-settings-env (getenv "DJANGO_SETTINGS_MODULE"))
        (default-directory (elpy-project-root)))
    ;; If no Django settings has been set, then nothing will work. Warn user
    (unless django-settings-env
      (error "Please set environment variable `DJANGO_SETTINGS_MODULE' if you'd like to run the test runner"))

    (let* ((runner-key (list default-directory django-settings-env))
           (runner (or (elpy-django--get-test-runner-from-cache runner-key)
                       (elpy-django--cache-test-runner
                        runner-key
                        (elpy-django--detect-test-runner django-settings-env)))))
      (elpy-django--limit-test-runner-cache-size)
      runner)))


(defun elpy-django--get-test-format ()
  "When running a Django test, some test runners require a different format than others.
Return the correct string format here."
  (let ((runner (elpy-django--get-test-runner))
        (found nil)
        (formats elpy-django-test-runner-formats))
    (while (and formats (not found))
      (let* ((entry (car formats)) (regex (car entry)))
        (when (string-match regex runner)
          (setq found (cdr entry))))
      (setq formats (cdr formats)))
    (or found (error (format "Unable to find test format for `%s'"
                             (elpy-django--get-test-runner))))))


(defun elpy-django--detect-test-runner (django-settings-env)
  "Detects django test runner in current configuration"
  ;; We have to be able to import the DJANGO_SETTINGS_MODULE to detect test
  ;; runner; if python process importing settings exits with error,
  ;; then warn the user that settings is not valid
  (unless (= 0 (call-process elpy-rpc-python-command nil nil nil
                             "-c" (format "import %s" django-settings-env)))
    (error (format "Unable to import DJANGO_SETTINGS_MODULE: '%s'"
                   django-settings-env)))
  (s-trim (shell-command-to-string
                       (format "%s -c '%s'" elpy-rpc-python-command
                               django-import-cmd))))


(defun elpy-django--get-test-runner-from-cache (key)
  "Retrieve from cache test runner with given caching key.
Return nil if the runner is missing in cache"
  (let ((runner (cdr (assoc key elpy-django--test-runner-cache))))
    ;; if present re-add to implement lru cache
    (when runner (elpy-django--cache-test-runner key runner))))


(defun elpy-django--cache-test-runner (key runner)
  "Store in test runner cache a runner with a key"""
  (push (cons key runner) elpy-django--test-runner-cache)
  runner)


(defun elpy-django--limit-test-runner-cache-size ()
  "Ensure elpy-django--test-runner-cache does not overflow a fixed size"
  (while (> (length elpy-django--test-runner-cache)
            elpy-django--test-runner-cache-max-size)
    (setq elpy-django--test-runner-cache (cdr elpy-django--test-runner-cache))))


;;;;;;;;;;;;;;;;;;;;;;
;;; User Functions

(defun elpy-django-command (cmd)
  "Prompt user for Django command. If called with `C-u',
it will prompt for other flags/arguments to run."
  (interactive (list (completing-read "Command: " (elpy-django--get-commands) nil nil)))
  ;; Called with C-u, variable is set or is a cmd that requires an argument
  (when (or current-prefix-arg
            elpy-django-always-prompt
            (member cmd elpy-django-commands-with-req-arg))
    (setq cmd (concat cmd " " (read-shell-command (concat cmd ": ") "--noinput"))))
  ;;
  (cond ((string= cmd "shell")
         (run-python (concat elpy-django-command " shell -i python") t t))
        (t
         (let* ((program (car (split-string elpy-django-command)))
                (args (cdr (split-string elpy-django-command)))
                (buffer-name (format "django-%s" (car (split-string cmd)))))
           (when (get-buffer (format "*%s*" buffer-name))
             (kill-buffer (format "*%s*" buffer-name)))
           (pop-to-buffer
            (apply 'make-comint buffer-name program nil
                   (append args (split-string cmd))))))))

(defun elpy-django-runserver (arg)
  "Start the server and automatically add the ipaddr and port.
Also create it's own special buffer so that we can have multiple
servers running per project.

When called with a prefix (C-u), it will prompt for additional args."
  (interactive "P")
  (let* ((cmd (concat elpy-django-command " " elpy-django-server-command))
         (proj-root (if (elpy-project-root)
                        (file-name-base (directory-file-name
                                         (elpy-project-root)))
                      (message "Elpy cannot find the root of the current django project. Starting the server in the current directory: '%s'."
                               default-directory)
                      default-directory))
         (buff-name (format "*runserver[%s]*" proj-root)))
    ;; Kill any previous instance of runserver since we might be doing something new
    (when (get-buffer buff-name)
      (kill-buffer buff-name))
    (setq cmd (concat cmd " " elpy-django-server-ipaddr ":" elpy-django-server-port))
    (when (or arg elpy-django-always-prompt)
      (setq cmd (concat cmd " "(read-shell-command (concat cmd ": ")))))
    (compile cmd)
    (with-current-buffer "*compilation*"
      (rename-buffer buff-name))))

(defun elpy-test-django-runner (top _file module test)
  "Test the project using the Django discover runner,
or with manage.py if elpy-test-django-with-manage is true.

This requires Django 1.6 or the django-discover-runner package."
  (interactive (elpy-test-at-point))
  (if module
      (apply #'elpy-test-run
             top
             (append
              (list elpy-django-command)
              elpy-django-test-runner-args
              (list (if test
                        (format "%s%s%s" module (elpy-django--get-test-format) test)
                      module))))
    (apply #'elpy-test-run
           top
           (append
            (list elpy-django-command)
            elpy-django-test-runner-args))))
(put 'elpy-test-django-runner 'elpy-test-runner-p t)

(define-minor-mode elpy-django
  "Minor mode for Django commands."
  :group 'elpy-django)

(provide 'elpy-django)
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;; elpy-django.el ends here
Commit	Line	Data
53e6db90 DC	1	;;; elpy-django.el --- Django extension for elpy
	2
	3	;; Copyright (C) 2013-2019 Jorgen Schaefer
	4
	5	;; Author: Daniel Gopar <gopardaniel@gmail.com>
	6	;; URL: https://github.com/jorgenschaefer/elpy
	7
	8	;; This program is free software; you can redistribute it and/or
	9	;; modify it under the terms of the GNU General Public License
	10	;; as published by the Free Software Foundation; either version 3
	11	;; of the License, or (at your option) any later version.
	12
	13	;; This program is distributed in the hope that it will be useful,
	14	;; but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	;; GNU General Public License for more details.
	17
	18	;; You should have received a copy of the GNU General Public License
	19	;; along with this program. If not, see <http://www.gnu.org/licenses/>.
	20
	21	;;; Commentary:
	22
	23	;; This file serves as an extension to elpy by adding django support
	24
	25	;;; Code:
	26
	27	(require 's)
	28
	29	;;;;;;;;;;;;;;;;;;;;;;
	30	;;; User customization
	31
	32	(defcustom elpy-django-command "django-admin.py"
	33	"Command to use when running Django specific commands.
	34	Best to set it to full path to 'manage.py' if it's available."
	35	:type 'string
	36	:safe 'stringp
	37	:group 'elpy-django)
	38	(make-variable-buffer-local 'elpy-django-command)
	39
	40	(defcustom elpy-django-server-ipaddr "127.0.0.1"
	41	"What address Django will use when running the dev server."
	42	:type 'string
	43	:safe 'stringp
	44	:group 'elpy-django)
	45	(make-variable-buffer-local 'elpy-django-server-ipaddr)
	46
	47	(defcustom elpy-django-server-port "8000"
	48	"What port Django will use when running the dev server."
	49	:type 'string
	50	:safe 'stringp
	51	:group 'elpy-django)
	52	(make-variable-buffer-local 'elpy-django-server-port)
	53
	54	(defcustom elpy-django-server-command "runserver"
	55	"When executing `elpy-django-runserver' what should be the server
	56	command to use."
	57	:type 'string
	58	:safe 'stringp
	59	:group 'elpy-django)
	60	(make-variable-buffer-local 'elpy-django-server-command)
	61
	62	(defcustom elpy-django-always-prompt nil
	63	"When non-nil, it will always prompt for extra arguments
	64	to pass with the chosen command."
65	:type 'boolean
66	:safe 'booleanp
67	:group 'elpy-django)
68	(make-variable-buffer-local 'elpy-django-always-prompt)
69
70	(defcustom elpy-django-commands-with-req-arg '("startapp" "startproject"
71	"loaddata" "sqlmigrate"
72	"sqlsequencereset"
73	"squashmigrations")
74	"Used to determine if we should prompt for arguments. Some commands
75	require arguments in order for it to work."
76	:type 'list
77	:safe 'listp
78	:group 'elpy-django)
79	(make-variable-buffer-local 'elpy-django-commands-with-req-arg)
80
81	(defcustom elpy-django-test-runner-formats '(("django_nose.NoseTestSuiteRunner" . ":")
82	(".*" . "."))
83	"List of test runners and their format for calling tests.
84
85	The keys are the regular expressions to match the runner used in test,
86	while the values are the separators to use to build test target path.
87	Some tests runners are called differently. For example, Nose requires a ':' when calling specific tests,
88	but the default Django test runner uses '.'"
89	:type 'list
90	:safe 'listp
91	:group 'elpy-django)
92	(make-variable-buffer-local 'elpy-django-test-runner-formats)
93
94	(defcustom elpy-django-test-runner-args '("test" "--noinput")
95	"Arguments to pass to the test runner when calling tests."
96	:type '(repeat string)
97	:group 'elpy-django)
98	(make-variable-buffer-local 'elpy-django-test-runner-args)
99
100	(defcustom elpy-test-django-runner-command nil
101	"Deprecated. Please define Django command in `elpy-django-command' and
102	test arguments in `elpy-django-test-runner-args'"
103	:type '(repeat string)
104	:group 'elpy-django)
105	(make-obsolete-variable 'elpy-test-django-runner-command nil "March 2018")
106
107	(defcustom elpy-test-django-runner-manage-command nil
108	"Deprecated. Please define Django command in `elpy-django-command' and
109	test arguments in `elpy-django-test-runner-args'."
110	:type '(repeat string)
111	:group 'elpy-django)
112	(make-obsolete-variable 'elpy-test-django-runner-manage-command nil "March 2018")
113
114	(defcustom elpy-test-django-with-manage nil
115	"Deprecated. Please define Django command in `elpy-django-command' and
116	test arguments in `elpy-django-test-runner-args'."
117	:type 'boolean
118	:group 'elpy-django)
119	(make-obsolete-variable 'elpy-test-django-with-manage nil "March 2018")
120
121	;;;;;;;;;;;;;;;;;;;;;;
122	;; Key map
123
124	(defvar elpy-django-mode-map
125	(let ((map (make-sparse-keymap)))
126	(define-key map (kbd "c") 'elpy-django-command)
127	(define-key map (kbd "r") 'elpy-django-runserver)
128	map)
129	"Key map for django extension")
130
131	;;;;;;;;;;;;;;;;;;;;;;
132	;;; Helper Functions
133
134	(defun elpy-django-setup ()
135	"Decides whether to start the minor mode or not."
136	;; Make sure we're in an actual file and we can find
137	;; manage.py. Otherwise user will have to manually
138	;; start this mode if they're using 'django-admin.py'
139	(when (locate-dominating-file default-directory "manage.py")
140	;; Let's be nice and point to full path of 'manage.py'
141	;; This only affects the buffer if there's no directory
142	;; variable overwriting it.
143	(setq elpy-django-command
144	(expand-file-name (concat (locate-dominating-file default-directory "manage.py") "manage.py")))
145	(elpy-django 1)))
146
147	(defun elpy-project-find-django-root ()
148	"Return the current Django project root, if any.
149
150	This is marked with 'manage.py' or 'django-admin.py'."
151	(or (locate-dominating-file default-directory "django-admin.py")
152	(locate-dominating-file default-directory "manage.py")))
153
154	(defun elpy-django--get-commands ()
155	"Return list of django commands."
156	(let ((dj-commands-str nil)
157	(help-output
158	(shell-command-to-string (concat elpy-django-command " -h"))))
159	(setq dj-commands-str
160	(with-temp-buffer
161	(progn
162	(insert help-output)
163	(goto-char (point-min))
164	(delete-region (point) (search-forward "Available subcommands:" nil nil nil))
165	;; cleanup [auth] and stuff
166	(goto-char (point-min))
167	(save-excursion
168	(while (re-search-forward "\\[.*\\]" nil t)
169	(replace-match "" nil nil)))
170	(buffer-string))))
171	;; get a list of commands from the output of manage.py -h
172	;; What would be the pattern to optimize this ?
173	(setq dj-commands-str (split-string dj-commands-str "\n"))
174	(setq dj-commands-str (cl-remove-if (lambda (x) (string= x "")) dj-commands-str))
175	(setq dj-commands-str (mapcar (lambda (x) (s-trim x)) dj-commands-str))
176	(sort dj-commands-str 'string-lessp)))
177
178
179	(defvar elpy-django--test-runner-cache nil
180	"Internal cache for elpy-django--get-test-runner.
181	The cache is keyed on project root and DJANGO_SETTINGS_MODULE env var")
182
183	(defvar elpy-django--test-runner-cache-max-size 100
184	"Maximum number of entries in test runner cache")
185
186
187	(defun elpy-django--get-test-runner ()
188	"Return the name of the django test runner.
189	Needs `DJANGO_SETTINGS_MODULE' to be set in order to work.
190	The result is memoized on project root and `DJANGO_SETTINGS_MODULE'"
191	(let ((django-import-cmd "import django;django.setup();from django.conf import settings;print(settings.TEST_RUNNER)")
192	(django-settings-env (getenv "DJANGO_SETTINGS_MODULE"))
193	(default-directory (elpy-project-root)))
194	;; If no Django settings has been set, then nothing will work. Warn user
195	(unless django-settings-env
196	(error "Please set environment variable `DJANGO_SETTINGS_MODULE' if you'd like to run the test runner"))
197
198	(let* ((runner-key (list default-directory django-settings-env))
199	(runner (or (elpy-django--get-test-runner-from-cache runner-key)
200	(elpy-django--cache-test-runner
201	runner-key
202	(elpy-django--detect-test-runner django-settings-env)))))
203	(elpy-django--limit-test-runner-cache-size)
204	runner)))
205
206
207	(defun elpy-django--get-test-format ()
208	"When running a Django test, some test runners require a different format than others.
209	Return the correct string format here."
210	(let ((runner (elpy-django--get-test-runner))
211	(found nil)
212	(formats elpy-django-test-runner-formats))
213	(while (and formats (not found))
214	(let* ((entry (car formats)) (regex (car entry)))
215	(when (string-match regex runner)
216	(setq found (cdr entry))))
217	(setq formats (cdr formats)))
218	(or found (error (format "Unable to find test format for `%s'"
219	(elpy-django--get-test-runner))))))
220
221
222	(defun elpy-django--detect-test-runner (django-settings-env)
223	"Detects django test runner in current configuration"
224	;; We have to be able to import the DJANGO_SETTINGS_MODULE to detect test
225	;; runner; if python process importing settings exits with error,
226	;; then warn the user that settings is not valid
227	(unless (= 0 (call-process elpy-rpc-python-command nil nil nil
228	"-c" (format "import %s" django-settings-env)))
229	(error (format "Unable to import DJANGO_SETTINGS_MODULE: '%s'"
230	django-settings-env)))
231	(s-trim (shell-command-to-string
232	(format "%s -c '%s'" elpy-rpc-python-command
233	django-import-cmd))))
234
235
236	(defun elpy-django--get-test-runner-from-cache (key)
237	"Retrieve from cache test runner with given caching key.
238	Return nil if the runner is missing in cache"
239	(let ((runner (cdr (assoc key elpy-django--test-runner-cache))))
240	;; if present re-add to implement lru cache
241	(when runner (elpy-django--cache-test-runner key runner))))
242
243
244	(defun elpy-django--cache-test-runner (key runner)
245	"Store in test runner cache a runner with a key"""
246	(push (cons key runner) elpy-django--test-runner-cache)
247	runner)
248
249
250	(defun elpy-django--limit-test-runner-cache-size ()
251	"Ensure elpy-django--test-runner-cache does not overflow a fixed size"
252	(while (> (length elpy-django--test-runner-cache)
253	elpy-django--test-runner-cache-max-size)
254	(setq elpy-django--test-runner-cache (cdr elpy-django--test-runner-cache))))
255
256
257	;;;;;;;;;;;;;;;;;;;;;;
258	;;; User Functions
259
260	(defun elpy-django-command (cmd)
261	"Prompt user for Django command. If called with `C-u',
262	it will prompt for other flags/arguments to run."
263	(interactive (list (completing-read "Command: " (elpy-django--get-commands) nil nil)))
264	;; Called with C-u, variable is set or is a cmd that requires an argument
265	(when (or current-prefix-arg
266	elpy-django-always-prompt
267	(member cmd elpy-django-commands-with-req-arg))
268	(setq cmd (concat cmd " " (read-shell-command (concat cmd ": ") "--noinput"))))
269	;;
270	(cond ((string= cmd "shell")
271	(run-python (concat elpy-django-command " shell -i python") t t))
272	(t
273	(let* ((program (car (split-string elpy-django-command)))
274	(args (cdr (split-string elpy-django-command)))
275	(buffer-name (format "django-%s" (car (split-string cmd)))))
276	(when (get-buffer (format "%s" buffer-name))
277	(kill-buffer (format "%s" buffer-name)))
278	(pop-to-buffer
279	(apply 'make-comint buffer-name program nil
280	(append args (split-string cmd))))))))
281
282	(defun elpy-django-runserver (arg)
283	"Start the server and automatically add the ipaddr and port.
284	Also create it's own special buffer so that we can have multiple
285	servers running per project.
286
287	When called with a prefix (C-u), it will prompt for additional args."
288	(interactive "P")
289	(let* ((cmd (concat elpy-django-command " " elpy-django-server-command))
290	(proj-root (if (elpy-project-root)
291	(file-name-base (directory-file-name
292	(elpy-project-root)))
293	(message "Elpy cannot find the root of the current django project. Starting the server in the current directory: '%s'."
294	default-directory)
295	default-directory))
296	(buff-name (format "runserver[%s]" proj-root)))
297	;; Kill any previous instance of runserver since we might be doing something new
298	(when (get-buffer buff-name)
299	(kill-buffer buff-name))
300	(setq cmd (concat cmd " " elpy-django-server-ipaddr ":" elpy-django-server-port))
301	(when (or arg elpy-django-always-prompt)
302	(setq cmd (concat cmd " "(read-shell-command (concat cmd ": ")))))
303	(compile cmd)
304	(with-current-buffer "compilation"
305	(rename-buffer buff-name))))
306
307	(defun elpy-test-django-runner (top _file module test)
308	"Test the project using the Django discover runner,
309	or with manage.py if elpy-test-django-with-manage is true.
310
311	This requires Django 1.6 or the django-discover-runner package."
312	(interactive (elpy-test-at-point))
313	(if module
314	(apply #'elpy-test-run
315	top
316	(append
317	(list elpy-django-command)
318	elpy-django-test-runner-args
319	(list (if test
320	(format "%s%s%s" module (elpy-django--get-test-format) test)
321	module))))
322	(apply #'elpy-test-run
323	top
324	(append
325	(list elpy-django-command)
326	elpy-django-test-runner-args))))
327	(put 'elpy-test-django-runner 'elpy-test-runner-p t)
328
329	(define-minor-mode elpy-django
330	"Minor mode for Django commands."
331	:group 'elpy-django)
332
333	(provide 'elpy-django)
334	;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
335	;;; elpy-django.el ends here