Bagaimana git membantu menangani skenario di bawah ini:

Saya memiliki tugas yang dibagi menjadi 2 bagian: tugas backend dan tugas frontend. Saya membuat permintaan tarik untuk menggabungkan perubahan backend dan menunggu untuk digabung (dan mengatasi umpan balik). Sambil menunggu, saya tidak bisa benar-benar bekerja pada perubahan frontend karena itu tergantung pada perubahan backend dan itu belum tersedia di cabang master.

Apa cara terbaik untuk menarik perubahan ke cabang perubahan frontend dari cabang perubahan backend saat sedang ditinjau?

Saya terkadang memiliki masalah ini. Git sangat fleksibel. Inilah salah satu cara Anda dapat melakukannya.

Cabang pertama Anda featureAsiap ditinjau.

Cabang kedua Anda featureBsedang dalam pengembangan dan tergantung pada kode di featureAcabang tersebut.

Gabungkan featureAcabang ke featureBcabang.

Jika Anda membuat perubahan pada featureAcabang maka Anda harus menggabungkan featureAcabang ke featureBcabang lagi untuk memasukkan perubahan.

Anda juga harus memastikan untuk bergabung featureAke dalam trunk utama terlebih dahulu, jika tidak ketika Anda menggabungkan featureBke trunk utama Anda secara tidak sengaja juga akan bergabung featureA. Setelah featureAdigabungkan ke dalam bagasi utama Anda dapat menyingkirkan featureAcabang karena featureBhanya tergantung pada bagasi utama sekarang.

Saya lebih suka ketika cabang fitur saya tidak saling bergantung tetapi kadang-kadang mereka melakukannya dan Anda harus menggunakannya.

Tunggu, lewati penggabungan

Untuk pendekatan ini, Anda tidak ingin menggabungkan feature_ake dalam feature_bberulang kali.

Rebasing telah disebutkan dalam jawaban lain, tetapi hanya untuk rebasing master. Apa yang ingin Anda lakukan dalam kasus Anda adalah:

• Mulai feature_bdari Anda feature_a, yaitu:

  git checkout feature_a
  git checkout -b feature_b
  

• Setiap kali feature_aperubahan saat menunggu untuk digabungkan master, Anda rebase feature_b di atasnya:

  ... commit something onto feature_a ...
  git checkout feature_b
  git rebase feature_a
  

• Akhirnya, segera setelah feature_adigabungkan master, Anda hanya mendapatkan yang baru masterdan rebase feature_ake atasnya untuk yang terakhir kali:

  git checkout master
  git pull origin master
  git checkout feature_b
  git rebase --onto master feature_a feature_b
  

  Rebase akhir ini akan mencangkokkan semua komit yang menggantung dari feature_akomit (yang sekarang tidak relevan karena telah digabungkan ke dalam master) langsung ke master. feature_bCabang Anda sekarang sederhana, standar langsung dari master.

EDIT: terinspirasi dari komentar, sedikit kepala di atas: jika Anda perlu membuat beberapa perubahan yang memengaruhi kedua fitur, maka pastikan untuk membuatnya feature_a(dan kemudian rebase seperti yang ditunjukkan). Jangan tidak membuatnya dalam dua komit yang berbeda di kedua cabang, bahkan jika mungkin menggoda; seperti feature_abagian dari sejarah feature_b, memiliki satu perubahan dalam dua komit yang berbeda akan secara semantik salah dan mungkin mengarah pada konflik atau "kebangkitan" kode yang tidak diinginkan, kemudian.

Anda sudah memiliki cabang tempat setiap cabang fitur Anda bergantung, dan yang terus berubah. Itu disebut master.

Cara khas agar cabang fitur tetap sinkron masteradalah tetap di atasnya. Ketika masterberubah, Anda biasanya git fetch origin master:master && git rebase masterdi direktori kerja cabang Anda.

Anda dapat melakukan hal yang sama dengan cabang fitur lain: tetap ambil dan rebasing di atasnya.

Jika, untuk beberapa alasan, Anda akan perlu untuk memindahkan perubahan pada cabang yang berbeda, Anda dapat ceri-memilih Anda komit, yang tidak pernah dicampur dengan komit cabang lain.

Dalam kasus ini di mana tugas frontend memiliki ketergantungan kritis pada kode backend, dan Anda ingin mulai bekerja di frontend sebelum backend diselesaikan dan diterima pada master, saya hanya akan memulai tugas frontend sebagai cabang fitur yang keluar dari backend branch, daripada bercabang frontend pada master.

Cabang fitur yang cukup lama perlu menggabungkan perubahan dari master secara berkala (untuk memastikan Anda merekonsiliasi penggabungan atau konflik semantik sebagai bagian dari pekerjaan pengembangan di cabang fitur, bukan sebagai bagian dari "review, qa, merge- untuk menguasai "proses). Jadi Anda melakukannya di cabang ujung depan Anda, dan ketika pekerjaan backend telah diterima untuk dikuasai, Anda akan mendapatkan perubahan kecil apa pun yang dilakukan pada backend sebagai bagian dari tinjauan / penerimaan secara otomatis, dengan rute yang sama dengan yang Anda inginkan. dapatkan perubahan kode lainnya pada master.

Jika ternyata cabang backend membutuhkan lebih banyak pekerjaan dan terus berubah selama periode waktu sebelum digabungkan untuk dikuasai (katakanlah jika masalah utama ditemukan selama peninjauan), maka Anda mungkin ingin melakukan penggabungan berkala secara langsung dari cabang backend ke cabang frontend (jadi Anda tidak terus mendasarkan semua pekerjaan frontend Anda pada kode backend usang). Ini mudah jika Anda adalah satu-satunya pengembang yang melakukan kedua fitur (karena Anda tahu jika Anda sendiri membuat perubahan besar), tetapi bahkan jika kedua fitur tersebut akhirnya dikerjakan secara paralel oleh pengembang yang berbeda, itu harus baik-baik saja; Anda hanya perlu tetap berkomunikasi (yang perlu Anda lakukan, jika Anda mengerjakan tugas secara paralel di mana satu memiliki ketergantungan kritis terhadap yang lain).

Jika ternyata seluruh cabang backend perlu ditinggalkan dan tidak akan pernah digabung (sepertinya ini akan menjadi masalah yang cukup besar yang jarang terjadi), maka Anda baik-baik saja memilih komitmen Anda ke cabang baru yang berasal dari master tanpa kerja backend, atau Anda menerapkan komit terbalik yang menghapus semua kode backend ke cabang frontend. Tapi seperti yang saya lihat, akan lebih mungkin untuk menghentikan pekerjaan frontend sampai Anda tahu apa yang akan menggantikan backend yang Anda buang, dan kemudian memutuskan apa yang harus dilakukan.

Saya tidak melihat masalah di sini.

Anda sudah memiliki ini setiap waktu dengan mastercabang Anda , yang terus berubah saat fitur dikembangkan dan kemudian digabung.

Jadi, dalam contoh konkret Anda, Anda pertama kali membuat feature_xxx_backendcabang dan mengembangkan perubahan backend. Ketika ini selesai, cabang akan meninjau dan akan digabung menjadi mastersetelah review selesai.

Jadi, cukup mulai cabang lain feature_yyy_frontend,. Anda mungkin ingin bercabang langsung feature_xxx_backend, sehingga Anda sudah memiliki perubahan-perubahan itu di branc Anda. kemudian cukup mengembangkan fitur frontend asif cabang master.

Ketika feature_xxx_backendcabang berubah, misalnya karena ada hal-hal yang muncul selama peninjauan yang perlu ditekankan, lakukan saja perubahan ini dan gabungkan mereka ke dalam feature_yyy_frontendcabang. Kemudian lanjutkan di cabang frontend.

Setelah peninjauan cabang backend selesai, itu akan digabung menjadi master. Pada titik ini, akan lebih bijaksana untuk rebase yang feature_yyy_frontendcabang ke master, sehingga pengulas hanya perlu meninjau baru perubahan yang cabang ini memberikan kontribusi untuk master, dan tidak perlu meninjau ulang perubahan yang dibuat untuk backend (yang telah disetujui ).

Ini juga dapat dilakukan ketika Anda memiliki dua, tiga atau lebih cabang tergantung. Jika Anda memiliki dua cabang fitur yang Anda andalkan, sederhana buatlah cabang turunan yang menggabungkan kedua fitur. Cabang dari sana, kembangkan fitur ketiga, gabungkan kedua cabang fitur di sepanjang jalan ketika masing-masing berubah. Ketika kedua fitur selesai dan digabung ke salah satu cabang yang diturunkan, rebase ke itu, atau jika mereka digabung menjadi master, rebase ke master.

Rebasing (seperti yang disarankan di atas) sangat kuat dan membantu menjaga log perubahan yang bersih, membuat ulasan menjadi lebih mudah.

Seperti yang disebutkan Polygnome, Anda sebenarnya bisa menggabungkan cabang frontend Anda dengan cabang backend Anda alih-alih master. Bahkan dengan pengaturan cabang saat ini yang Anda miliki sekarang, Anda dapat melakukannya:

git checkout frontend
git merge backend

atau sederhana

git merge backend frontend

Perlu diingat bahwa jika perubahan backend tidak diterima dan diperlukan lebih banyak pekerjaan, Anda harus menggabungkan pembaruan dari backend ke frontend untuk menghindari konflik. Setelah perubahan diterima ke master, Anda bisa rebase frontend Anda pada master untuk menyingkirkan komitmen backend merge.

Secara teknis Anda juga bisa melakukan semuanya dengan rebase, tetapi itu akan mengacaukan sejarah commit dari cabang frontend Anda. Dari mana saya berasal, ini dianggap praktik yang buruk. YMMV

Sebagian besar jawaban di sini dengan benar menjelaskan proses menggabungkan perubahan dari cabang kedua ke yang pertama, tetapi mereka tidak membahas cara meminimalkan jumlah konflik yang mungkin perlu Anda selesaikan.

Setiap kali Anda memiliki dua set perubahan besar yang ingin Anda tinjau secara individual (seperti featureAdan featureB), buat PR yang TIDAK dimaksudkan untuk digabungkan, tetapi untuk mengumpulkan umpan balik awal pada PoC featureA.

Orang-orang akan dapat memeriksanya dengan cepat (itu hanya PoC), dan tujuannya adalah untuk memvalidasi desain atau pendekatan umum.

Kemudian, Anda dapat terus bekerja pada fitur A, membuat permintaan tarik untuk itu dan cabang dan bekerja pada fitur B.

Perbedaan besar adalah bahwa sekarang Anda dapat berharap featureAuntuk tidak berubah secara radikal: desain dan pendekatan sudah divalidasi. Tinjauan kode dan perubahan yang diperlukan mungkin lebih halus dan lokal daripada "woops, Anda memerlukan pendekatan yang berbeda". Ini akan meminimalkan jumlah pekerjaan yang harus Anda lakukan untuk nanti menggabungkan featureBpada featureA's kode, terlepas dari metode yang Anda pilih.