https://github.com/pythonic-emacs/djangonaut
Emacs minor mode for Django.
https://github.com/pythonic-emacs/djangonaut
Last synced: 5 months ago
JSON representation
Emacs minor mode for Django.
- Host: GitHub
- URL: https://github.com/pythonic-emacs/djangonaut
- Owner: pythonic-emacs
- License: gpl-3.0
- Created: 2018-01-09T23:37:07.000Z (over 7 years ago)
- Default Branch: master
- Last Pushed: 2024-07-21T10:58:33.000Z (9 months ago)
- Last Synced: 2024-08-05T06:05:08.615Z (9 months ago)
- Language: Emacs Lisp
- Size: 3.6 MB
- Stars: 40
- Watchers: 6
- Forks: 7
- Open Issues: 0
-
Metadata Files:
- Readme: README.markdown
- License: LICENSE
Awesome Lists containing this project
README
# 
Djangonaut [](https://www.gnu.org/software/emacs/) [](https://travis-ci.org/proofit404/djangonaut)
Emacs minor mode for Django.
[](https://melpa.org/#/djangonaut)
[](https://github.com/pythonic-emacs/djangonaut/actions/workflows/test.yml)
This package is based on the introspection of your Django project. It
executes Python code to get all necessary information about model,
views, and templates inside `INSTALLED_APPS`. Works the same way for
applications written by you and for third-party code installed with
`pip`.
No more broken code conventions. No more flaky guesses about your
project layout. If Django can understand it, Djangonaut can
understand it.
## Features
Djangonaut mode provides following features
* intelligent navigation in a Django project
* management commands execution
* works transparently with vagrant, docker and remote hosts
## Supported Python Versions
2.7, 3.4, 3.5, 3.6
## Supported Django Versions
1.8, 1.9, 1.10, 1.11, 2.0
## Installation
All you need to do is install the package from
[Melpa](https://melpa.org/)
M-x package-install RET djangonaut RET
## Configuration
Djangonaut minor mode available in all buffers related to current
django project (python and html files, dired buffers). First of all
enable minor mode:
M-x global-djangonaut-mode RET
Now you need to configure Emacs environment to run your django
project. For example, `run-python` command should be able to run
django shell. Emacs require to know three things:
* path to the python interpreter or virtual environment
* location of the project
* django settings module of your project
#### Path to the interpreter
Django itself is a python package you usually install with `pip`.
If you install Django into your system globally with `apt` or `yum`
you can skip this section. But most of times python packages are
installed somewhere else like virtual environment on your host, inside
Docker container or virtual machine orchestrated by Vagrant.
If you setup project inside virtual environment, use this command to
tell Emacs where it can find an interpreter:
M-x pythonic-activate RET /path/to/your/venv/ RET
If you use Docker or Docker Compose for development, open any of the
project files using tramp. Optionally you can specify interpreter
location inside container. Also you need to install
[docker-tramp](https://github.com/emacs-pe/docker-tramp.el) package to
use remote interpreter this way.
C-x C-f /docker:root@container:/app/config/urls.py
;; Optionally...
M-x set-variable RET python-shell-interpreter RET "/usr/local/bin/python"
If you use Vagrant for development, first of all add your ssh key to
the trusted list in your VM, so you will not be annoyed with password
prompt pops up frequently. Then open any project file in the running
virtual machine.
;; SSH config (done once).
ssh-copy-id vagrant@localhost -p 2222
;; Open project file (each time at the begging).
C-x C-f /ssh:vagrant@localhost#2222:/app/config/urls.py
Optionally point Emacs to the remote interpreter this way
M-x set-variable RET python-shell-interpreter RET "/usr/bin/python" RET
#### Path to the project
The key point here - provided python interpreter should be able to
import modules from your project. There is a lot of options here.
You can use [setuptools](https://setuptools.readthedocs.io/en/latest/)
to wrap your project into proper python package and install it into
editable mode
pip install -e .
You can use `pth` file to include project location into interpreter
import path
echo $PWD > venv/lib/python3.7/site-packages/project.pth
Or you can use old plain `PYTHONPATH` environment variable to tell
Emacs where to look for your project
M-x set-variable RET python-shell-extra-pythonpaths RET '("/path/to/the/project/")
In case you use Docker you can also set this variable directly inside
container either with command line arguments or via
[environment](https://docs.docker.com/compose/compose-file/) key of
the docker compose file
docker run -e PYTHONPATH=/code/ web django-admin runserver 0.0.0.0:8000
#### Settings module
Also Emacs needs to know your django settings module. We can provide
it the same way as we do with project path via environment variable
M-x set-variable RET python-shell-process-environment RET '("DJANGO_SETTINGS_MODULE=project.settings")
And in the case of docker you can setup this variable inside container
directly or with compose file environment key
docker run -e DJANGO_SETTINGS_MODULE=project.settings web ...
### Configuration via .dir-locals.el
Another way to set the above variables is via [directory variables](https://www.gnu.org/software/emacs/manual/html_node/emacs/Directory-Variables.html). The values you set will then be valid when editing all files in the directory where `.dir-locals.el` is located and all directories underneath that one. To set the same values as in the examples above, we would use the following `.dir-locals.el` file:
((nil
(python-shell-process-environment . ("DJANGO_SETTINGS_MODULE=project.settings"))
(python-shell-extra-pythonpaths . ("/path/to/the/project/"))
(python-shell-virtualenv-root . "/path/to/your/venv/")))
Note that you should specify `nil` for the major-mode specification in the directory variables, indicating that the values will be valid in all Emacs buffers associated with files under the directory, not just, say, buffers of open Python files.
## Usage
If you open file or directory related to the project, you should see
`Django` minor mode is activated for this buffer. Note, you should
open project files over tramp method, if you use remote interpreter.
For example, open `/docker:root@container:/code/manage.py` instead of
`manage.py` on the local host.
#### Project navigation
| Key | Command |
|----------------------|------------------------------------|
| C-c ' M | djangonaut-find-model-manager |
| C-c ' S | djangonaut-find-settings-module |
| C-c ' a | djangonaut-find-admin-class |
| C-c ' c | djangonaut-find-management-command |
| C-c ' h | djangonaut-find-template-filter |
| C-c ' g | djangonaut-find-template-tag |
| C-c ' i | djangonaut-dired-installed-apps |
| C-c ' j | djangonaut-find-static-file |
| C-c ' m | djangonaut-find-model |
| C-c ' n | djangonaut-find-migration |
| C-c ' p | djangonaut-find-drf-permission |
| C-c ' q | djangonaut-find-sql-function |
| C-c ' r | djangonaut-find-signal-receiver |
| C-c ' s | djangonaut-find-drf-serializer |
| C-c ' f | djangonaut-find-form |
| C-c ' w | djangonaut-find-widget |
| C-c ' t | djangonaut-find-template |
| C-c ' u | djangonaut-find-url-module |
| C-c ' v | djangonaut-find-view |
| C-c ' d | djangonaut-find-middleware |
All navigation commands can open definitions in the other window. For
example use C-c ' 4 m to open model definition in the other
window.
#### Run management commands
Use C-c ' ! to run management command in the comint buffer.
You can call it with prefix argument `C-u` to set command arguments
via interactive menu.
