Tertarik membalas kepada komunitas kecil? Mungkin Anda menemukan bug di Django yang ingin Anda perbaiki, atau mungkin ada fitur kecil yang ingin Anda tambahkan.
\nMembantu kembali ke Django adalah cara terbaik untuk melihat alamat perhatian anda. ini mungkin terlihat menakutkan awalnya, tetapi itu adalah jalur bepergian-dengan-baik dengan dokumentasi, peralatan, dan komunitas untuk mendukung anda. Kami akan berjalan melalui proses keseluruhan, sehingga anda dapat belajar berdasarkan contoh.
\nUntuk tutorial ini, kami berharap bahwa anda mempunyai setidaknya pengertian dasar bagaimana Django bekerja. Ini berarti anda harus nyaman melalui tutorial yang ada pada writing your first Django app. Sebagai tambahan, anda harus mempunyai pemahaman bagus dari Phyton itu sendiri. Tetapi jika anda tidak, Dive Into Python adalah luar biasa (dan gratis) buku daring untuk programer pemula Phyton.
\nBagi anda yang tidak akrab dengan vesi kendali sistem dan Trac akan menemukan bahwa tutorial ini dan tautannya memasukkan informasi cukup untuk memulai. Bagaimanapun, anda akan mungkin membaca beberapa lebih alat berbeda jika anda berencana sering untuk membantu Django.
\nUntuk sebagian besar, tutorial ini mencoba menjelaskan sebanyak mungkin, sehingga itu dapat digunakan pada pendengar luas.
\n\nKami akan berjalan bersama anda dalam membantu tambakan ke Django untuk pertama kali. Pada akhir tutorial ini, anda harus mempunyai pengertian dasar dari kedua alat dan pengolahan yang terlibat. Khususnya, kami akan mencangkup berikut:
\nMemasang Git
Mengunduh salinan versi pengembangan Django.
Menjalankan rangkaian percobaan Django.
Menulis percobaan untuk tambalan anda.
Menulis kode untuk tambalan anda.
Mencoba tambahan anda.
Mengajukan pull request
Dimana mencari untuk informasi lebih.
Sekali anda selesai dengan tutorial, anda dapat mencari sisa dari Django's documentation on contributing. Itu mengandung banyak informasi hebat dan harus dibaca untuk siapapun yang suka menjadi penyumbang rutin ke Django. Jika anda mendapatkan pertanyaan, itu mungkin mendapatkan jawaban.
\n\n\nSebagai penyumbang, anda dapat membantu kami menjaga komunitas Django terbuka dan inklusif. Silahkan baca dan ikuti ``Code of Conduct <https://www.djangoproject.com/conduct/>`_ kami.
\nUntuk tutorial ini, anda akan membutuhkan Git terpasang untuk mengunduh versi pengembangan saat ini dari Django dan membangkitkan berkas tambalan untuk perubahan anda buat.
\nUntuk memeriksa apakah atau tidak anda telah terpasang Git, masukkan git ke baris perintah. Jika anda mendapatkan pesan dimana perintah ini tidak ditemukan, anda akan perlu mengunduh dan memasangnya, lihat Halaman unduh Git.
Jika anda tidak akrab dengan Git, anda dapat selalu menemukan lebih tentang perintahnya (pertama dia dipasang) dengan mengetik git help kedalam baris perintah.
Langkah pertama untuk membantu Django adalah mendapatkan sebuah salinan dari kode sumber. Pertama, fork Django on GitHub. Kemudian, dari baris perintah, gunakan perintah cd untuk melayari ke direktori dimana anda akan ingin salinan lokal anda dari Django menjadi langsung.
Unduh gudang kode sumber Django menggunakan perintah berikut:
\nLinux / macOS
$ git clone https://github.com/YourGitHubName/django.git\nWindows
...\\> git clone https://github.com/YourGitHubName/django.git\nSekarang dimana anda memiliki salinan lokal Django, anda dapat memasang itu seperti anda memasang paket apapun menggunakan pip. Cara paling nyaman melakukannya adalah dengan menggunakan virtual environment, yaitu fitur dibangun kedalam Python yang mengizinkan anda menjaga direktori terpisah dari paket-paket terpasang untuk setiap dari proyek-proyek anda sehingga mereka tidak mengganggu satu sama lain.
Itu adalah ide bagus menjaga semua lingkungan maya anda dalam satu tempat, sebagai contoh dalam .virtualenvs/ di direktori rumah anda.
Buat lingkungan maya baru dengan menjalankan:
\nLinux / macOS
$ python3 -m venv ~/.virtualenvs/djangodev\nWindows
...\\> py -m venv %HOMEPATH%\\.virtualenvs\\djangodev\nJalur dimana lingkungan baru akan disimpan ke komputer anda.
\nlangkah akhir dalam mengatur lingkungan maya adalah mengaktifkan itu:
\n$ source ~/.virtualenvs/djangodev/bin/activate\nJika perintah source tidak tersedua, anda dapat mencoba menggunakan titik:
$ . ~/.virtualenvs/djangodev/bin/activate\nAnda harus mengaktifkan lingkungan virtual setiap kali Anda membuka jendela terminal baru.
\n\nNama dari lingkungan maya diaktivasi sekarang ditampilkan pada baris perintah untuk membantu anda melacak dimana yang anda sedang gunakan. Apapun anda pasang melalui pip selagi nama ini ditampilkan akan dipasang dalam lingkungan maya, terpencil dari lingkungan dan paket-paket sistem-lebar.
Lanjutkan dan pasang klon salinan sebelumnya dari Django:
\nLinux / macOS
$ python -m pip install -e /path/to/your/local/clone/django/\nWindows
...\\> py -m pip install -e \\path\\to\\your\\local\\clone\\django\\\nVersi Django terpasang sekarang menunjuk pada salinan lokal anda dengan memasang dalam suasana data disunting. Anda akan segera melihat perubahan apapun anda buat kepadanya, dimana adalah bantuan besar ketika menulis tambalan pertama anda.
\nIt may be helpful to test your local changes with a Django project. First you\nhave to create a new virtual environment, install the previously cloned\nlocal copy of Django in editable mode,\nand create a new Django project outside of your local copy of Django. You will\nimmediately see any changes you make to Django in your new project, which is\nof great help when writing your first patch, especially if testing any changes\nto the UI.
\nYou can follow the tutorial for help in creating a\nDjango project.
\nKetika membantu Django adalah sangat penting bahwa perubahan kode anda tidak memperkenalkan kesalahan kedalam kawasan Django lain. Satu cara untuk memeriksa bahwa Django masih bekerja setelah anda membuat perubahan anda adalah dengan menjalankan deretan percobaan Django. Jika semua percobaan masih terlewati, lalu anda cukup yakin bahwa perubahan anda bekerja dan tidak merusak bagian lain dari Django. Jika anda tidak pernah menjalankan deretan percobaan Django sebelumnya, adalah ide bagus untuk menjalankannya sekali sebelumnya untuk lebih akrab dengan keluarannya.
\nSebelum menjalankan deretan pengujian, masukkan direktori tests/ Django menggunakan perintah cd tests dan pasang ketergantungan pengujian dengan menjalankan:
Linux / macOS
$ python -m pip install -r requirements/py3.txt\nWindows
...\\> py -m pip install -r requirements\\py3.txt\nJika anda mengalami sebuah kesalahan selama pemasangan, sisem anda mungkin kehilangan ketergantungan untuk satu atau lebih paket Python. Obrolkan dokumentasi paket yang gagal atau cari di jaringan dengan pesan kesalahan yang anda alami.
\nSekarang kita siap menjalankan deretan percobaan. Jika anda menggunakan GNU/Linux, macOS, atau beberapa Unix rasa lainnya, jalankan:
\nLinux / macOS
$ ./runtests.py\nWindows
...\\> runtests.py \nSekarang duduk dan rileks. Keseluruhan rangkaian pengujian Django mempunyai ribuan pengujian, dan itu membutuhkan paling sedikit beberapa menit untuk dijalankan, tergantung pada kecepatan komputer anda.
\nSelagi deretan percobaan Django berjalan, anda akan melihat aliran karakter mewakili keadaan dari setiap percobaan sampai itu lengkap. E menunjukkan bahwa sebuah kesalahan memunculkan selama percobaan, dan F menunjukkan bahwa tuntutan percobaan gagal. Kedua dari ini dipertimbangkan menjadi kegagalan percobaan. Sementara itu, x dan s menunjukkan diharapkan kegagalan dan melewati percobaan, masing-masing. Titik menunjukkan percobaan lolos.
Lewati percobaan biasanya karena kehilangan pustaka luar yang diwajibkan untuk menjalankan percobaan; lihat Menjalankan semua percobaan untuk daftar dari ketergantungan dan pastikan memasang tiap untuk percobaan terhubung ke perubahan anda sedang buat (kami tidak akan butuh untuk tutorial ini). Beberapa percobaan sangat khusus pada backend basisdata tertentu dan akan dilewati jika tidak dicobakan dengan backend itu. SQLite adalah backend basisdata untuk pengaturan awal. Untuk menjalankan percobaan menggunakan backend berbeda, lihat Gunakan modul pengaturan lain.
\nKetika percobaan lengkap, anda akan disapa dengan pesan menginformasikan bahwa deretan percobaan lulus atau gagal. Sejak anda tidak mempunyai perubahan apapun ke kode Django, deretan percobaan seluruhnya harus lulus. Jika anda mendapatkan kegagalan atau kesalahan pastikan anda telah mengikuti langkah sebelumnya dengan benar. Lihat Menjalankan satuan percobaan untuk informasi lebih.
\nCatat bahwacabang "main" Django mungkin tidak selalu stabil. Ketika mengembangkan terhadap "main", anda dapat memeriksa Django's continuous integration builds untuk menentukan jika kegagalan spesifik pada mesin anda atau jika mereka juga hadir dalam bangunan resmi Django. Jika anda mengklik untuk melihat bangunan tertentu, anda dapat melihat "Configuration Matrix" yang menunjukkan kegagalan dipecah oleh versi Python dan backend basisdata.
\n\nUntuk pengajaran tambahan ini, kami akan bekerja pada "tiket palsu" sebagai sebuah kasus pelajaran. Disini adalah rincian gambaran:
\n\nKami akan menerapkan fitur ini dan percobaan terkait.
\nSebelum membuat perubahan apapun, buat sebuah cabang baru untuk tiket:
\nLinux / macOS
$ git checkout -b ticket_99999\nWindows
...\\> git checkout -b ticket_99999\nAnda dapat memilih nama apapun yang anda ingin untuk cabang, "ticket_99999" adalah sebuah contoh. Semua perubahan dibuat dalam cabang ini akan khusus pada tiket dan tidak akan mempengaruhi salinan uta,a dari kode yang kami kloning diawal.
\nDalam kebanyakan kasus, untuk tambalan diterima kedalam Django dia harus disertakan percobaan. Untuk tambalan perbaikan kesalahan, ini berarti menulis percobaan pemulihan untuk memastikan bahwa kesalahan tidak pernah diperkenalkan kembali kedalam Django kemudian. Percobaan pemulihan harus ditulis dalam cara tersebut yang dia akan gagal selama kesalahan masih ada dan lulus ketika kesalahan telah diperbaiki. Untuk tambalan mengandung fitur baru, anda akan butuh menyertakan percobaan yang memastikan fitur baru bekerja dengan benar. Mereka juga akan gagal ketika fitur baru tidak hadir, dan lalu lulus ketika dia telah diterapkan.
\nJalan baik untuk melakukannya ini adalah pertama menulis percobaan baru anda, sebelum membuat perubahan apapun ke kode. Gaya ini dari pengembangan dipanggil test-driven development dan dapat diberlakukan untuk kedua proyek keseluruhan dan tambalan tunggal. Setelah menulis percobaan anda, anda kemudian jalankan mereka untuk memastikan bahwa mereka memang gagal (sejak anda belum memperbaiki kesalahan tersebut atau ditambahkan fitur tersebut). Jika percobaan baru anda tidak gagal, anda akan butuh memperbaiki mereka sehingga mereka melakukannya. Lagipula, percobaan pemulihan yang lulus tanpa memperhatikan apakah kesalahan hadir tidak sangat membantu dalam mencegah kesalahan dari terjadi di jalan.
\nSekarang untuk contoh meneruskan kami.
\nUntuk menyelesaikan tiket ini, kami akan menambahkan sebuah fungsi make_toast() ke dalam modul django.shortcuts. Pertama kami akan menulis sebuah pengujian yang mencoba menggunakan fungsi dan memeriksa bahwa keluarannya terlihat benar.
Kemudikan ke folder tests/shortcuts/ Django dan buat sebuah berkas baru test_make_toast.py. Tambah kode berikut:
from django.shortcuts import make_toast\nfrom django.test import SimpleTestCase\n\n\nclass MakeToastTests(SimpleTestCase):\n def test_make_toast(self):\n self.assertEqual(make_toast(), "toast")\nPercobaan ini memeriksa bahwa make_toast() mengembalikan 'toast'.
Sejak kami belum membuat perubahan apapun pada django.shortcuts, percobaan kami harus gagal. Mari kita jalankan semua percobaan dalam folder shortcuts untuk memastikan bahwa itu memang terjadi. cd ke direktori tests/ Django dan jalankan:
Linux / macOS
$ ./runtests.py shortcuts\nWindows
...\\> runtests.py shortcuts\nIf the tests ran correctly, you should see one failure corresponding to the test\nmethod we added, with this error:
\nImportError: cannot import name 'make_toast' from 'django.shortcuts'\nJika semua percobaan dilewati, kemudian anda akan ingin memastikan bahwa anda menambahkan percobaan terbaru ditampilkan diatas pada folder dan nama berkas sesuai.
\nSelanjutnya kami akan menambahkan fungsi make_toast().
Kemudikan ke folder django/ dan buka berkas shortcuts.py. Pada bagian bawah, tambah:
def make_toast():\n return "toast"\nSekarang kami butuh memastikan bahwa percobaan kami tulis sebelumnya lolos, jadi kami dapat melihat apakah kode kami tambahkan bekerja dengan benar. Kembali, kemudikan ke direktori tests/ Django dan jalankan:
Linux / macOS
$ ./runtests.py shortcuts\nWindows
...\\> runtests.py shortcuts\nSemuanya harus dilewatkan. Jika itu tidak, pastikan anda dengan benar menambahkan fungsi ke berkas benar.
\nSetelah anda memngecek bahwa tambalan anda dan percobaan anda bekerja dengan benar, adalah ide bagus menjalankan deretan percobaan Django seluruhnya untuk memastikan bahwa perubahan anda tidak memperkenalkan kesalahan apapun kedalam kawasan lain dari Django. Selagi berhasil melewati deretan percobaan keseluruhan tidak menjamin kode anda bebas kesalahan, itu membantu mencirikan banyak kesalahan dan pemulihan yang mungkin sebaliknya luput dari perhatian.
\nUntuk menjalankan seluruh rangkaian percobaan Django, cd kedalam direktori test/ Django dan jalankan:
Linux / macOS
$ ./runtests.py\nWindows
...\\> runtests.py \nThis is a new feature, so it should be documented. Open the file\ndocs/topics/http/shortcuts.txt and add the following at the end of the\nfile:
``make_toast()``\n================\n\n.. function:: make_toast()\n\n.. versionadded:: 2.2\n\nReturns ``'toast'``.\nSince this new feature will be in an upcoming release it is also added to the\nrelease notes for the next version of Django. Open the release notes for the\nlatest version in docs/releases/, which at time of writing is 2.2.txt.\nAdd a note under the "Minor Features" header:
:mod:`django.shortcuts`\n~~~~~~~~~~~~~~~~~~~~~~~\n\n* The new :func:`django.shortcuts.make_toast` function returns ``'toast'``.\nUntuk informasi lebih dalam menulis dokumen, termasuk penjelasan dari apa semua tentang bit versionadded, lihat Menulis dokumentasi. Halaman itu juga menyertakan sebuah penjelasan dari bagaimana membangun salinan dari dokumentasi secara lokal, sehingga anda dapat meninjau HTML yang akan dibangkitkan.
Sekarang saatnya melalui semua perubahan dibuat dalam tambalan kami. Untuk melancarkan semua perubahan siap diserahkan, jalankan:
\nLinux / macOS
$ git add --all\nWindows
...\\> git add --all\nKemudian tampilkan perbedaan diantara salinan saat ini dari Django (dengan perubahan anda) dan perbaikan yang anda awali periksa di paling awal dengan petunjuk penggunaan:
\nLinux / macOS
$ git diff --cached\nWindows
...\\> git diff --cached\nGunakan kunci panah untuk pindah ke atas dan ke bawah.
\ndiff --git a/django/shortcuts.py b/django/shortcuts.py\nindex 7ab1df0e9d..8dde9e28d9 100644\n--- a/django/shortcuts.py\n+++ b/django/shortcuts.py\n@@ -156,3 +156,7 @@ def resolve_url(to, *args, **kwargs):\n\n # Finally, fall back and assume it's a URL\n return to\n+\n+\n+def make_toast():\n+ return 'toast'\ndiff --git a/docs/releases/2.2.txt b/docs/releases/2.2.txt\nindex 7d85d30c4a..81518187b3 100644\n--- a/docs/releases/2.2.txt\n+++ b/docs/releases/2.2.txt\n@@ -40,6 +40,11 @@ database constraints. Constraints are added to models using the\n Minor features\n --------------\n\n+:mod:`django.shortcuts`\n+~~~~~~~~~~~~~~~~~~~~~~~\n+\n+* The new :func:`django.shortcuts.make_toast` function returns ``'toast'``.\n+\n :mod:`django.contrib.admin`\n ~~~~~~~~~~~~~~~~~~~~~~~~~~~\n\ndiff --git a/docs/topics/http/shortcuts.txt b/docs/topics/http/shortcuts.txt\nindex 7b3a3a2c00..711bf6bb6d 100644\n--- a/docs/topics/http/shortcuts.txt\n+++ b/docs/topics/http/shortcuts.txt\n@@ -271,3 +271,12 @@ This example is equivalent to::\n my_objects = list(MyModel.objects.filter(published=True))\n if not my_objects:\n raise Http404("No MyModel matches the given query.")\n+\n+``make_toast()``\n+================\n+\n+.. function:: make_toast()\n+\n+.. versionadded:: 2.2\n+\n+Returns ``'toast'``.\ndiff --git a/tests/shortcuts/test_make_toast.py b/tests/shortcuts/test_make_toast.py\nnew file mode 100644\nindex 0000000000..6f4c627b6e\n--- /dev/null\n+++ b/tests/shortcuts/test_make_toast.py\n@@ -0,0 +1,7 @@\n+from django.shortcuts import make_toast\n+from django.test import SimpleTestCase\n+\n+\n+class MakeToastTests(SimpleTestCase):\n+ def test_make_toast(self):\n+ self.assertEqual(make_toast(), 'toast')\nKetika anda selesai meninjau tambalan, kenai kunci q untuk kembali ke baris perintah. Jika isi tambalan terlihat oke, waktunya memperbaiki perubahan.
Memperbaiki perubahan:
\nLinux / macOS
$ git commit\nWindows
...\\> git commit\nIni membuka penyunting teks untuk mengetik pesanperbaikan. Ikuti commit message guidelines dan tulis sebuah pesan seperti:
\nFixed #99999 -- Added a shortcut function to make toast.\nSetelah menyerahkan tambalan, kirim itu ke cabang dari GitHub (mengganti "ticket_99999" dengan nama dari cabang anda jika itu berbeda):
\nLinux / macOS
$ git push origin ticket_99999\nWindows
...\\> git push origin ticket_99999\nAnda dapat membuat sebuah pull request dengan mengunjungi Django GitHub page. Anda akan melihat cabang anda dibawah "Your recently pushed branches". Klik "Compare & pull request" dekatnya.
\nHarap jangan melakukan itu untuk tutorial ini. tetapi pada halaman selanjutnya yang memperlihatkan tinjauan dari tambalan, anda akan mengklik "Create pull request".
\nSelamat, anda telah belajar bagaimana membuat sebuah pull request pada Django! Rincian dari teknik-teknik lebih lanjut anda mungkin butuh adalah di Bekerja dengan Git dan GitHub.
\nSekarang anda dapat menaruh keahlian-keahlian tersebut untuk penggunaan bagus dengan membantu memperbaiki kode dasar Django.
\nSebelum anda terlalu kedalam menulis tambalan untuk Django, terdapat sedikit informasi lebih di bantuan yang anda harus mungkin lihat pada:
\nAnda harus pastikan membaca dokumentasi Django di claiming tickets and submitting patches. Itu melingkup tata cara Trac, bagaimana menyatakan tiket untuk anda sendiri, gaya pengkodean yang diharapkan untuk tambalan, dan banyak rincian penting lain.
Pertama kali penyumbang harus juga membaca documentation for first time contributors. Django. Itu mempunyai banyak saran baik untuk siapa dari kita yang baru untuk dibantu dengan Django.
Setelah itu, jika anda masih terburu-buru untuk informasi lebih tentang bantuan, anda dapat selalu menjelajah melalui sisa Django's documentation on contributing. Itu mengandung ton dari informasi berguna dan harus menjadi sumber pertama anda untuk menjawab pertanyaan papun anda mungkin punya.
Ketika anda telah mencari beberapa informasi itu, anda akan siap keluar dan menemukan tiket dari milik anda untuk menulis tambalan. Perhatian khusus ke tiket dengan standar "pemetikan mudah". Tiket ini sering banyak sederhana di alam dan hebat untuk pertama kali penyumbang. Ketika anda akrab dengan membantu ke Django, anda dapat pindah ke menulis tambalan untuk tiket lebih sulit dan rumit.
\nJika Anda hanya ingin memulai saja (dan tidak seorangpun akan menyalahkan anda!), coba lihat dari daftar easy tickets that need patches dan easy tickets that have patches which need improvement. Jika anda akrab dengan percobaan menulis, anda dapat juga melihat daftar easy tickets that need tests. Ingatlah untuk mengikuti panduan mengenai klaim tiket yang disebutkan dalam tautan pada dokumentasi Django di claiming tickets and submitting patches.
\nSetelah tiket mempunyai tambalan, itu butuh ditinjau dengan sekumpulan mata kedua. Setelah mengajukan permintaan penarikan, perbaharui metadata tiket dengan mengatur bendera di tiket untuk mengatakan "punya tambalan", "tidak butuh percobaan", dll, sehingga lainnya dapat menemukannya untuk ditinjau. Membantu tidak perlu selalu berarti menulis tambalan dari awal. Meninjau tambalan yang ada juga sangat membantu. Lihat Mendahulukan tiket untuk rinci.
\n