Menulis tambalan pertama anda untuk Django

Kata Pengantar

Tertarik dalam memberikan kembali ke komunitas sedikit? Mungkin anda telah menemukan kesalahan di Django yang anda ingin melihat diperbaiki, atau mungkin terdapat fitur baru yang anda ingin tambahkan.

Membantu kembali Django itu sendiri adalah jalan terbaik untuk melihat masalah anda sendiri ditangani. Ini mungkin terlihat menakutkan pertama kali, tetapi itu sangat mudah. Kami akan berjalan bersama anda melalui pengolahan seluruhnya, sehingga anda dapat belajar berdasarkan contoh.

Untuk siapa saja tutorial ini?

lihat juga

Jika anda mencari referensi bagaimana mengajukan tambalan, lihat dokumentasi Mengajukan tambalan.

Untuk 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.

Bagi 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.

Untuk sebagian besar, tutorial ini mencoba menjelaskan sebanyak mungkin, sehingga itu dapat digunakan pada pendengar luas.

Dimana mendapatkan bantuan:

Jika anda mempunyai masalah melalui tutorial ini, siahkan tempatkan pesan ke django-developers atau jatuhkan dengan #django-dev on irc.freenode.net untuk mengobrol dengan pengguna Django lainnya yang mungkin dapat membantu.

Tutorial ini meliputi apa?

Kami 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:

  • Memasang Git
  • Bagaimana mengunduh pengembangan salinan 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.

Python 3 wajib!

Tutorial ini menganggap anda sedang menggunakan Python 3. Dapatkan versi terakhir pada Python's download page atau dengan pengelola paket sistem operasi anda.

Untuk pengguna Windows

Ketika memasang Python di Windows, pastikan anda mencentang pilihan "Tambah phyton.exe ke Jalur", sehingga dia selalu tersedia di baris perintah.

Kode Etik

Sebagai penyumbang, anda dapat membantu kami menjaga komunitas Django terbuka dan inklusif. Silahkan baca dan ikuti ``Code of Conduct <https://www.djangoproject.com/conduct/>`_ kami.

Memasang Git

Untuk tutorial ini, anda akan membutuhkan Git terpasang untuk mengunduh versi pengembangan saat ini dari Django dan membangkitkan berkas tambalan untuk perubahan anda buat.

Untuk 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.

Untuk pengguna Windows

Ketika memasang Git pada Windows, sangat dianjurkan bahwa anda mengambil pilihan "Git Bash" sehingga Git berjalan di shell sendiri. Tutorial ini menganggap bahwa anda telah memasangnya.

Jika anda tidak akrab dengan Git, anda dapat selalu menemukan lebih tentang perintahnya (pertama dia dipasang) dengan mengetik git help kedalam baris perintah.

Mendapatkan salinan versi pengembangan Django

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:

$ git clone git@github.com:YourGitHubName/django.git

Sekarang bahwa anda mempunyai salinan lokal Django, anda dapat memasangnya seperti anda akan memasang paket apapun menggunakan pip. Cara paling mudah melakukannya adalah dengan menggunakan virtual environment (or virtualenv) dimana fitur tersebut dibangun kedalam Phyton yang mengizinkan anda untuk menjaga direktori terpisah dari paket terpasang untuk setiap proyek anda sehingga mereka tidak mengganggu satu sama lain.

Adalah ide bagus untuk menjaga virtualenv anda dalam satu tempat, sebagai contoh dalam .virtualenvs/ di direktori rumah anda. Buatlah jika itu tidak ada:

$ mkdir ~/.virtualenvs

Sekarang buat virtualenv baru dengan menjalankan:

$ python3 -m venv ~/.virtualenvs/djangodev

Jalur dimana lingkungan baru akan disimpan ke komputer anda.

Untuk pengguna Windows

Menggunakan modul venv terpasang teptap tidak akan bekerja jika juga menggunakan shell Git Bash di Windows, sejak tulisan aktivasi hanya dibuat untuk sistem shell (.bat) and PowerShell (.ps1). Gunakan paket virtualenv:

$ pip install virtualenv
$ virtualenv ~/.virtualenvs/djangodev

Untuk pengguna Ubuntu

Pada beberapa versi Ubuntu perintah diatas mungkin gagal. Gunakan paket virtualenv, pertama pastikan anda mempunyai pip3:

$ sudo apt-get install python3-pip
$ # Prefix the next command with sudo if it gives a permission denied error
$ pip3 install virtualenv
$ virtualenv --python=`which python3` ~/.virtualenvs/djangodev

Langkah akhir dalam mengatur virtualenv anda adalah untuk mengaktifkannya:

$ source ~/.virtualenvs/djangodev/bin/activate

Jika perintah source tidak tersedua, anda dapat mencoba menggunakan titik:

$ . ~/.virtualenvs/djangodev/bin/activate

Untuk pengguna Windows

Untuk mengaktifkan virtualenv anda pada Windows, jalankan:

$ source ~/virtualenvs/djangodev/Scripts/activate

Anda harus mengaktifkan virtualenv kapanpun anda membuka jendela terminal baru. virtualenvwrapper adalah alat berguna untuk membuat ini lebih mudah.

Apapun anda pasang mealui pip mulai sekarang akan dipasang di virtualenv baru anda, terpencil dari lingkungan lain dan paket sistem-lebar. Juga, nama dari virtualenv yang diaktifkan saat ini ditampilkan pada baris perintah untuk membantu anda tetap melacak yang mana anda gunakan. Pergilah dan pasang salinan kloning sebelumnya dari Django:

$ pip install -e /path/to/your/local/clone/django/

Versi terpasang dari Django sekarang menunjuk pada salinan lokal anda. Anda akan segera melihat perubahan apapun anda buat, yang merupakan bantuan hebat ketika menulis tambalan pertama anda.

Gulir kembali ke perubahan sebelum dari Django

Untuk tutorial ini, kami akan menggunakan tiket #24788 sebagai pembelajaran kasus, jadi kami akan memutar kembali sejarah versi Django di git sebelum tambalan tiket tersebut diberlakukan. Ini akan mengizinkan kami melalui semua langkah terlibat dalam penulisan tambalan dari coretan, termasuk menjalankan deretan percobaan Django.

Ingat-ingat bahwa selama kami akan menggunakan perubahan lama dari trunk Django untuk tujuan dari tutorial dibawah, anda harus selalu menggunakan perubahan pengembangan saat ini dari Django ketika bekerja pada tambahan sendiri untuk tiket!

Catatan

Tambalan untuk tiket ini ditulis oleh Paweł Marczewski, dan itu berlaku ke Django sebagai commit 4df7e8483b2679fc1cba3410f08960bac6f51115. Oleh karena itu, kami akan menggunakan perbaikan Django hanya sebelum itu, commit 4ccfc4439a7add24f8db4ef3960d02ef8ae09887.

Jelajahi kedalam direktori akar Django (itu yang mengandung django, docs, tests, AUTHORS, etc.). Anda dapat lalu memeriksa perbaikan lama Django yang akan kita gunakan dalam tutorial dibawah:

$ git checkout 4ccfc4439a7add24f8db4ef3960d02ef8ae09887

Menjalankan rangkaian percobaan Django untuk pertama kali

Ketika membantu Django sangat penting bahwa perubahan kode anda tidak menimbulkan kesalahan kedalam kawasan lain dari Django. Satu cara memeriksa bahwa Django masih bekerja setelah anda membuat perubahan adalah dengan menjalankan deretan percobaan Django. Jika semua percobaan masih terlewati, lalu anda dapat beralasan yakin bahwa perubahan anda tidak akan merusak Django. Jika anda tidak pernah menjalankan deretan percobaan Django sebelumnya, adalah ide bagus untuk menjalankannya sekali sebelumnya untuk mendapatkan keakraban dengan keluarannya sesuai dengan seharusnya.

Sebelum menjalankan deretan percobaan, pasang ketergantungannya dengan pertama men cd kan kedalam direktori tests/ Django dan kemudian jalankan:

$ pip install -r requirements/py3.txt

Jika anda menjumpai sebuah kesalahan selama pemasangan, sistem anda mungkin kehilangan ketergantungan dari satu atau lebih paket-paket Python. Rundingkan dokumentasi paket-paket gagal atau cari Jaringan dengan pesan kesalahan yang anda jumpai.

Sekarang kita siap menjalankan deretan percobaan. Jika anda menggunakan GNU/Linux, macOS, atau beberapa Unix rasa lainnya, jalankan:

$ ./runtests.py

Sekarang duduk dan santai, Deretan percobaan keseluruhan Django telah lebih 9,600 percobaan berbeda, sehingga itu dapat diambil dimanapun dari 5 sampai 15 menit untuk berjalan, tergantung pada kecepatan komputer anda.

Selama deretan percobaan Django berjalan, anda akan melihat aliran karakter yang mewakili keadaan dari setiap percobaan ketika itu berjalan. E mengindikasikan bahwa sebuah kesalahan muncul selama percobaan, dan F mengindikasikan bahwa pernyataan percobaan gagal. Kedua dari ini dianggap menjadi kegagalan percobaan. Sementara itu, x dan s mengindikasikan kegagalan yang diharapkan dan melewati percobaan, masing-masing. Titik mengindikasikan lulus percobaan.

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.

Segera setelah percobaan lengkap, anda harus disambut dengan sebuah pesan yang menginformasikan anda apakah deretan percobaan lolos atau gagal. Sejak anda belum membuat perubahan apapun pada kode Django, deretan percobaan keseluruhan harus lolos. Jika anda mendapatkan kegagalan atau kesalahan pastikan anda telah mengikuti semua langkah-langkah sebelumnya dengan benar. Lihat Menjalankan satuan percobaan untuk informasi lebih. Jika anda sedang menggunakan Python 3.5+, akan ada sepasang kegagalan pada peringatan pengusangan yang anda dapat abaikan. Kegagalan ini telah sejak diperbaiki di Django.

Catat bahwa trunk Django terakhir mungkin tidak selalu stabil. Ketika mengembangkan terhadap bagasi, anda dapat memeriksa Bangun terpadu lanjut Django untuk menentukan jika kegagalan spesifik ke mesin anda atau jika mereka juga hadir di bangun resmi Django. Jika anda klik untuk melihat bangun tertentu, anda dapat melihat "Konfigurasi Matrix" yang menampilkkan kegagalan dibongkar oleh versi Phyton dan backend basisdata.

Catatan

Untuk tutorial ini dan tiket yang kita sedang bekerja, percobaan terhadap SQLite adalah cukup, bagaimanapun, ini memungkinkan (dan terkadang butuh) untuk menjalankan percobaan menggunakan basisdata berbeda.

Membuat sebuah cabang untuk tambalan anda

Sebelum membuat perubahan apapun, buat sebuah cabang baru untuk tiket:

$ git checkout -b ticket_24788

Anda dapat memilih nama apapun yang anda ingin untuk cabang, "ticket_24788" adalah sebuah contoh. Semua perubahan dibuat di cabang ini akan dikhususkan ke tiket dan tidak akan mempengaruhi salinan utama dari kode yang kami kloning sebelumnya.

Menulis beberapa percobaan untuk tiket anda

Dalam 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.

Jalan 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.

Sekarang untuk contoh meneruskan kami.

Menulis beberapa percobaan untuk tiket #24788

Tiket #24788 mengajukan tambahan fitur kecil: kemampuan untuk menentukan atribut tingkatan kelas awalan pada Bentuk kelas, sehingga:

[…] forms which ship with apps could effectively namespace themselves such
that N overlapping form fields could be POSTed at once and resolved to the
correct form.

Untuk menyelesaikan tiket ini, kami akan menambahkan atribut awalan pada kelas BaseForm. Ketika membuat instance dari kelas ini, melewati awalan ke cara __init__() akan masih menyetel awalan tersebut di instance dibuat. Tetapi tidak melewatkan awalan (atai melewati None) akan menggunakan awalan tingkatan-kelas. Sebelum kami membuat perubahan tersebut, kami akan menulis sepasang percobaan untuk mengecek bahwa perubahan fungsi kami benar dan lanjut ke fungsi benar di masa datang.

Arahkan ke pelipat tests/forms_tests/tests/ Django dan buka berkas test_forms.py. Tambah kode berikut di baris 1674 tepat sebelum fungsi test_forms_with_null_boolean

def test_class_prefix(self):
    # Prefix can be also specified at the class level.
    class Person(Form):
        first_name = CharField()
        prefix = 'foo'

    p = Person()
    self.assertEqual(p.prefix, 'foo')

    p = Person(prefix='bar')
    self.assertEqual(p.prefix, 'bar')

Percobaan baru ini memeriksa bahwa pengaturan awalan tingkatan kelas bekerja sesuai yang diharapkan, dan bahwa melewati parameter awalan ketika membuat sebuah instance masih bekerja juga.

Tetapi percobaan ini terlihat sangat sulit...

Jika anda tidak pernah berurusan dengan percobaan sebelumnya, mereka dapat kelihatan sedikir sulit untuk menulis pandangan pertama. Untungnya, percobaan adalah subyek sangat besar di pemrograman komputer, sehingga terdapat banyak informasi diluar sana:

  • Tampilan bagus pertama pada penulisan percobaan untuk Django dapat ditemukan di dokumentasi pada Menulis dan menjalankan percobaan.
  • Dive Into Python (sebuah buku daring bebas untuk pengembang Phyton pemula) termasuk Perkenalan ke Unit Percobaan hebat.
  • Setelah membaca itu, jika anda ingin sesuatu sedikit daging untuk menengelamkan gigi anda kedalamnya, selalu ada dokumentasi unittest Python.

Menjalankan percobaan baru anda

Ingat bahwa kita belum sebenarnya membuat perubahan apapun pada BaseForm, jadi percobaan kami akan gagal. Mari kita menjalankan semua percobaan di pelipat forms_tests untuk memastikan bahwa itu memang terjadi. Dari baris perintah, cd kedalam direktori tests/ Django dan jalankan:

$ ./runtests.py forms_tests

Jika percobaan berjalan dengan benar, anda harus melihat satu kegagalan terhubung dengan cara percobaan yang kita tambahkan. Jika semua percobaan lulus, lalu anda akan ingin memastikan bahwa anda menambahkan percobaan baru ke pelipat dan kelas yang sesuai.

Menulis kode untuk tiket anda

Selanjutnya kami akan menambahkan fungsi digambarkan di tiket #24788 pada Django.

Menulis kode untuk tiket #24788

Navigasikan ke pelipat django/django/forms/ dan buka berkas forms.py. Temukan kelas BaseForm di baris 72 dan tambah atribut kelas awalan tepat setelah atribut field_order

class BaseForm(object):
    # This is the main implementation of all the Form logic. Note that this
    # class is different than Form. See the comments by the Form class for
    # more information. Any improvements to the form API should be made to
    # *this* class, not to the Form class.
    field_order = None
    prefix = None

memeriksa percobaan anda sekarang lulus

Sekali anda telah selesai merubah Django, kami butuh memastikan bahwa percobaan kami tulis sebelumnya lulus, sehingga kami dapat melihat kode kami tulis diatas bekerja dengan benar. Untuk menjalankan percobaan di pelipat forms_tests, cd kedalam direktori tests/ Django dan jalankan:

$ ./runtests.py forms_tests

Ups, hal baik kami menulis percobaan tersebut! Anda harus masih melihat satu kegagalan dengan pengecualian berikut:

AssertionError: None != 'foo'

Kami lupa menambahkan pernyataan kondisi di cara __init__. Lanjutkan dan rubah self.prefix = prefix yang sekarang di baris 87 dari django/forms/forms.py, menambahkan pernyataan tambahan:

if prefix is not None:
    self.prefix = prefix

Jalankan-kembali percobaan dan semuanya harus lewati. Jika itu tidak, pastikan anda benar merubah kelas BaseForm seperti ditunjukkan diatas dan menyalin percobaan baru dengan benar.

Menjalankan rangkaian percobaan Django untuk kedua kali

Ketika anda telah memeriksa bahwa tambalan anda dan percobaan anda bekerja dengan benar, adalah ide bagus untuk menjalankan deretan percobaan Django keseluruhan hanya untuk menmeriksa bahwa perubahan anda tidak memunculkan kesalahan apapun kedalam kawasan lain Django. Ketika berhasil lulus deretan percobaan keseluruhan tidak menjamin kode anda bebas kesalahan, itu membantu mencirikan banyak kesalahan dan kemunduran yang mungkin tidak diketahui.

Untuk menjalankan seluruh rangkaian percobaan Django, cd kedalam direktori test/ Django dan jalankan:

$ ./runtests.py

Selama anda tidak melihat kegagalan apapun, anda bagus untuk berjalan.

Menulis Dokumentasi

Ini adalahfitur baru, sehingga harus didokumentasikan. Tambah bagian berikut pada baris 1068 (di akhir berkas) dari django/docs/ref/forms/api.txt:

The prefix can also be specified on the form class::

    >>> class PersonForm(forms.Form):
    ...     ...
    ...     prefix = 'person'

.. versionadded:: 1.9

    The ability to specify ``prefix`` on the form class was added.

Sejak fitur baru ini akan berada di terbitan akan datang itu juga ditambahkan ke catatan terbitan untuk Django 1.9, di baris 164 dibawah bagian "Forms" di berkas docs/releases/1.9.txt:

* A form prefix can be specified inside a form class, not only when
  instantiating a form. See :ref:`form-prefix` for details.

Untuk 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.

Pratinjau perubahan anda

Sekarang waktunya pergi melalui semua perubahan dibuat di tambalan kami. Untuk memperlihatkan perbedaan diantara salinan anda saat ini dari Django (dengan perubahan anda) dan pembetulan yang anda mulanya diperiksa lebih awal di tutorial:

$ git diff

Gunakan kunci panah untuk pindah ke atas dan ke bawah.

diff --git a/django/forms/forms.py b/django/forms/forms.py
index 509709f..d1370de 100644
--- a/django/forms/forms.py
+++ b/django/forms/forms.py
@@ -75,6 +75,7 @@ class BaseForm(object):
     # information. Any improvements to the form API should be made to *this*
     # class, not to the Form class.
     field_order = None
+    prefix = None

     def __init__(self, data=None, files=None, auto_id='id_%s', prefix=None,
                  initial=None, error_class=ErrorList, label_suffix=None,
@@ -83,7 +84,8 @@ class BaseForm(object):
         self.data = data or {}
         self.files = files or {}
         self.auto_id = auto_id
-        self.prefix = prefix
+        if prefix is not None:
+            self.prefix = prefix
         self.initial = initial or {}
         self.error_class = error_class
         # Translators: This is the default suffix added to form field labels
diff --git a/docs/ref/forms/api.txt b/docs/ref/forms/api.txt
index 3bc39cd..008170d 100644
--- a/docs/ref/forms/api.txt
+++ b/docs/ref/forms/api.txt
@@ -1065,3 +1065,13 @@ You can put several Django forms inside one ``<form>`` tag. To give each
     >>> print(father.as_ul())
     <li><label for="id_father-first_name">First name:</label> <input type="text" name="father-first_name" id="id_father-first_name" /></li>
     <li><label for="id_father-last_name">Last name:</label> <input type="text" name="father-last_name" id="id_father-last_name" /></li>
+
+The prefix can also be specified on the form class::
+
+    >>> class PersonForm(forms.Form):
+    ...     ...
+    ...     prefix = 'person'
+
+.. versionadded:: 1.9
+
+    The ability to specify ``prefix`` on the form class was added.
diff --git a/docs/releases/1.9.txt b/docs/releases/1.9.txt
index 5b58f79..f9bb9de 100644
--- a/docs/releases/1.9.txt
+++ b/docs/releases/1.9.txt
@@ -161,6 +161,9 @@ Forms
   :attr:`~django.forms.Form.field_order` attribute, the ``field_order``
   constructor argument , or the :meth:`~django.forms.Form.order_fields` method.

+* A form prefix can be specified inside a form class, not only when
+  instantiating a form. See :ref:`form-prefix` for details.
+
 Generic Views
 ^^^^^^^^^^^^^

diff --git a/tests/forms_tests/tests/test_forms.py b/tests/forms_tests/tests/test_forms.py
index 690f205..e07fae2 100644
--- a/tests/forms_tests/tests/test_forms.py
+++ b/tests/forms_tests/tests/test_forms.py
@@ -1671,6 +1671,18 @@ class FormsTestCase(SimpleTestCase):
         self.assertEqual(p.cleaned_data['last_name'], 'Lennon')
         self.assertEqual(p.cleaned_data['birthday'], datetime.date(1940, 10, 9))

+    def test_class_prefix(self):
+        # Prefix can be also specified at the class level.
+        class Person(Form):
+            first_name = CharField()
+            prefix = 'foo'
+
+        p = Person()
+        self.assertEqual(p.prefix, 'foo')
+
+        p = Person(prefix='bar')
+        self.assertEqual(p.prefix, 'bar')
+
     def test_forms_with_null_boolean(self):
         # NullBooleanField is a bit of a special case because its presentation (widget)
         # is different than its data. This is handled transparently, though.

Ketika anda selesai meninjau tambalan, kenai kunci q untuk kembali ke baris perintah. Jika isi tambalan terlihat oke, waktunya memperbaiki perubahan.

Memperbaiki perubahan di tambalan

Memperbaiki perubahan:

$ git commit -a

Ini membuka penyunting teks untuk mengetik pesanperbaikan. Ikuti commit message guidelines dan tulis sebuah pesan seperti:

Fixed #24788 -- Allowed Forms to specify a prefix at the class level.

Mendorong perbaikan dan membuat sebuah pull request

Setelah memperbaiki tambalan, kirim itu ke garpu pada GitHub (ganti "ticket_24788" dengan nama dari cabang anda jika itu berbeda):

$ git push origin ticket_24788

Anda 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.

Harap jangan melakukan itu untuk tutorial ini. tetapi pada halaman selanjutnya yang memperlihatkan tinjauan dari tambalan, anda akan mengklik "Create pull request".

Langkah-langkah selanjutnya

Selamat, 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.

Sekarang anda dapat menaruh keahlian-keahlian tersebut untuk penggunaan bagus dengan membantu memperbaiki kode dasar Django.

Informasi lebih untuk penyumbang baru

Sebelum anda terlalu kedalam menulis tambalan untuk Django, terdapat sedikit informasi lebih di bantuan yang anda harus mungkin lihat pada:

  • Anda 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.

Temukan tiket sungguhan pertama anda

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.

Jika anda hanya ingin segera mulai (dan tidak siapapun akan menyalahkan anda!), coba lihatlah daftar dari easy tickets that need patches dan easy tickets that have patches which need improvement. Jika anda akrab dengan menulis percobaan, anda dapat juga melihat daftar easy tickets that need tests. Hanya ingat untuk mengikuti panduan berikut tentang menyatakan tiket yang disebutkan di tautan pada dokumentasi Django di claiming tickets and submitting patches.

Apa selanjutnya setelah membuat sebuah pull request?

Setelah 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.

Apa yang akan dibaca selanjutnya
Menggunakan Django
Back to Top