Takip et

Kötü Commit Mesajlarına Veda: Conventional Commits Kullanımı

Git geçmişiniz bir karmaşaya mı benziyor? Ekip arkadaşlarınız commit mesajlarınızı anlamakta zorlanıyor, hatta siz bile birkaç hafta sonra ne yaptığınızı hatırlamakta güçlük mü çekiyorsunuz? Geliştirme süreçlerinizi verimsizleştiren, hata ayıklamayı kabusa çeviren bu sorunlara “Conventional Commits” ile kalıcı bir çözüm bulabilirsiniz. Bu makale, sizi kötü commit mesajlarından kurtarıp, sürüm kontrolü deneyiminizi baştan sona dönüştürecek standardize edilmiş bir commit mesajı yapısıyla tanıştıracak.

Bir yazılım projesinin kalbi, onun sürüm kontrol geçmişidir. Git gibi araçlar sayesinde kod tabanımızdaki her değişikliği, ne zaman yapıldığını ve kimin yaptığını takip edebiliriz. Ancak bu takip mekanizması, eğer değişikliklerin “neden” yapıldığını açıklayan commit mesajları yetersizse, kısa sürede bir bilgi çöplüğüne dönüşebilir. “Düzeltme”, “Güncelleme”, “Çalışıyor” gibi belirsiz commit mesajları ne yazık ki sektörde çok yaygın ve bu durum, tahmin edebileceğinizden çok daha fazla soruna yol açıyor.

Öncelikle, kötü commit mesajları ekip içi iletişimi zayıflatır. Bir ekip üyesi bir hata ile karşılaştığında veya belirli bir özelliği incelemesi gerektiğinde, ilgili değişikliği bulmak için tüm commit geçmişini tek tek okumak zorunda kalır. Eğer bu mesajlar “bir şeyler yaptım” düzeyindeyse, o commit’in tam olarak neyi amaçladığını veya hangi sorunu çözdüğünü anlamak neredeyse imkansız hale gelir. Bu durum, özellikle büyük ekiplerde ve karmaşık projelerde zaman kaybına, yanlış anlaşılmalara ve hatta gereksiz kod tekrarlarına neden olabilir. Kod incelemeleri de bu durumdan olumsuz etkilenir; bir geliştirici, yalnızca kod değişikliklerine bakarak commit’in niyetini çözmeye çalışır ki bu da hatalara davetiye çıkarır.

Hata ayıklama (debugging) süreci kötü commit mesajları yüzünden adeta bir labirente dönüşür. Bir hata ortaya çıktığında, hatanın hangi commit ile tanıtıldığını bulmak için git blame veya git bisect gibi araçlar kullanırız. Ancak eğer commit mesajları anlamsızsa, bu araçlar bize sadece “değişikliğin yapıldığı commit” bilgisini verir, “değişikliğin neden yapıldığı” veya “amacının ne olduğu” bilgisini değil. Bu da, hatayı gidermek için çok daha fazla zaman harcanmasına ve hatta bazen yanlış commit’lerin geri alınmasına yol açabilir. Projenin gelişimi boyunca biriken bu anlaşılmazlık, teknik borcun artmasına ve sürdürülebilirliğin azalmasına katkıda bulunur.

Ayrıca, otomatikleştirilmiş süreçler de kötü commit mesajlarından nasibini alır. Otomatik changelog (değişiklik günlüğü) oluşturma, otomatik sürüm yükseltme (semantic versioning) gibi araçlar, commit mesajlarını parse ederek çalışır. Eğer commit mesajları yapılandırılmamışsa, bu araçlar işlevsiz kalır ve bu süreçler elle yapılmak zorunda kalınır. Bu da hata riskini artırır ve CI/CD (Sürekli Entegrasyon/Sürekli Dağıtım) boru hattının potansiyelini sınırlar. Özetle, kötü commit mesajları sadece bir estetik problem değil, aynı zamanda projenizin sağlığını, ekip verimliliğini ve genel yazılım kalitesini doğrudan etkileyen ciddi bir teknik sorundur. Bu problemin üstesinden gelmenin yolu ise standartlaştırılmış bir yaklaşımdan geçiyor: Conventional Commits.

Conventional Commits Nedir ve Temel Bileşenleri Nelerdir?

Conventional Commits, commit mesajları için hafif bir kural kümesi tanımlayan bir spesifikasyondur. Bu spesifikasyon, insan tarafından okunabilir commit mesajları oluşturmaya ve aynı zamanda makine tarafından kolayca parse edilebilen bir format sağlamaya odaklanır. Amacı, daha anlamlı bir Git geçmişi oluşturarak yazılım geliştirme süreçlerini kolaylaştırmak ve otomatikleştirmek, böylece tüm ekibin faydalanmasını sağlamaktır. Conventional Commits, temelde her commit mesajının belirli bir yapıda olmasını şart koşar ve bu yapının her bileşeninin belirli bir anlamı vardır.

Bir Conventional Commit mesajının temel yapısı şu şekildedir:

(): 

[optional body]

[optional footer(s)]

Bu yapının her bir bileşenini ayrıntılı olarak inceleyelim:

  • (Tip): Bu kısım, yapılan değişikliğin ana amacını belirtir ve zorunludur. Projede nelerin değiştiğini tek bakışta anlamamızı sağlar. En yaygın kullanılan tipler şunlardır:
    • feat: Yeni bir özellik (feature) eklendiğinde kullanılır. Bu tür commitler genellikle minor sürüm artışına yol açar.
    • fix: Bir hata (bug) düzeltildiğinde kullanılır. Bu tür commitler genellikle patch sürüm artışına yol açar.
    • docs: Sadece dokümantasyon değişiklikleri yapıldığında.
    • style: Kodun formatlanması, noktalama işaretleri gibi anlamsal bir değişiklik olmayan stil düzeltmeleri.
    • refactor: Kodu yeniden yapılandırma (refactoring) ancak davranışında bir değişiklik olmaması.
    • test: Test ekleme veya mevcut testleri düzeltme.
    • chore: Yapılandırma dosyaları, derleme scriptleri gibi geliştirici araçları veya süreç değişiklikleri.
    • build: Derleme sistemi veya harici bağımlılıklar üzerinde yapılan değişiklikler.
    • ci: CI/CD yapılandırma dosyaları ve scriptlerindeki değişiklikler.
  • () (Kapsam - İsteğe Bağlı): Değişikliğin yapıldığı yer veya modülü tanımlar. Parantez içinde belirtilir ve projenin belirli bir bölümünü, örneğin feat(auth) veya fix(dashboard) şeklinde açıklamak için kullanılır. Kapsam, o commit'in hangi alt sisteme ait olduğunu hızlıca anlamamızı sağlar ve isteğe bağlı olsa da büyük projelerde oldukça faydalıdır.
  • : (Açıklama): Değişikliğin kısa ve öz bir özetidir. Tip ve kapsamdan sonra bir boşluk ve iki nokta üst üste ile başlar. Genellikle emir kipiyle (örn. "kullanıcı doğrulama ekle" yerine "kullanıcı doğrulamasını ekle") yazılır ve 50-72 karakteri geçmemesi önerilir. Bu açıklama, commit'in ne yaptığını tek bir satırda özetler ve Git geçmişinde anahtar bilgiyi sunar.
  • [optional body] (Gövde - İsteğe Bağlı): Commit mesajının asıl içeriğini, yani değişikliğin "neden" yapıldığını ve "nasıl" yapıldığını daha detaylı açıklayan kısımdır. Açıklama satırından sonra bir boş satır bırakılarak başlanır. Bu kısım, değişikliğin motivasyonunu, problem tanımını ve uygulanan çözümü ayrıntılı olarak anlatır. Özellikle karmaşık değişikliklerde veya potansiyel yan etkileri olan durumlarda çok değerlidir.
  • [optional footer(s)] (Dipnot(lar) - İsteğe Bağlı): Commit mesajının son kısmıdır ve genellikle referans bilgilerini içerir. Örneğin, ilgili hata takip sistemi (issue tracker) numaraları (örn. Closes #123, Refs #456) veya bir kırıcı değişiklik (breaking change) bilgisini belirtmek için kullanılır. En önemli dipnotlardan biri, büyük harflerle BREAKING CHANGE ile başlayan bir bildirimdir. Bu, API'de veya uygulamanın davranışında geriye dönük uyumsuz bir değişiklik yapıldığı anlamına gelir ve genellikle ana (major) sürüm artışına yol açar.

Bu yapılandırma, sadece insan okuyucular için değil, aynı zamanda Git geçmişini analiz eden otomatik araçlar için de büyük kolaylık sağlar. Örneğin, feat tipi commit'ler otomatik olarak yeni özellikler listesine dahil edilebilirken, fix tipi commit'ler düzeltilen hatalar listesine eklenebilir. BREAKING CHANGE ibaresi ise sürüm yönetim araçlarına önemli bir uyarı gönderir. Conventional Commits ile geliştiriciler, daha disiplinli bir şekilde çalışır, kod geçmişi daha şeffaf hale gelir ve yazılım kalitesi artar.

Uzman İpucu: Conventional Commits kullanmak, projenizdeki sürüm yönetimi (Semantic Versioning) süreçlerini otomatikleştirmenize olanak tanır. Örneğin, feat commit'leri minor, fix commit'leri patch ve BREAKING CHANGE içeren commit'ler major sürüm artışlarını tetikleyebilir.

Conventional Commits Nasıl Uygulanır? Adım Adım Rehber

Conventional Commits'i projenize entegre etmek, başlangıçta biraz alışkanlık gerektirse de, sunduğu faydalar sayesinde bu çabaya fazlasıyla değer. Bu bölümde, Conventional Commits yapısını adım adım nasıl uygulayacağınızı ve farklı senaryolar için örnek commit mesajlarını bulacaksınız. Unutmayın, tutarlılık bu sistemin anahtarıdır; ekip olarak benimsenen bir standart, en iyi sonuçları verecektir.

Temel Commit Mesajı Yapısı Nasıl Oluşturulur?

Başlangıç olarak, en temel commit mesajı yapısını ele alalım: (): . Bu yapı, her commit için zorunlu olan minimum bilgiyi sağlar. Git komut satırını kullanarak commit yaparken bu yapıyı kolayca uygulayabilirsiniz.

Örnek 1: Yeni Bir Özellik Ekleme

Bir kullanıcı kimlik doğrulama özelliği eklediğinizi varsayalım. Bu, yeni bir fonksiyonalite olduğu için feat tipini kullanırız. Kapsam olarak auth belirtebiliriz.

git commit -m "feat(auth): Kullanıcı girişi için JWT doğrulama eklendi"

Bu mesaj, hem otomatik araçlar hem de insan okuyucular için son derece açıklayıcıdır. Ne yapıldığı (yeni özellik), nerede yapıldığı (kimlik doğrulama) ve ne eklendiği (JWT doğrulama) net bir şekilde belirtilmiştir.

Örnek 2: Bir Hatayı Düzeltme

Uygulamada bir sepet (cart) hatası olduğunu ve bu hatayı düzelttiğinizi düşünelim. Bu durumda fix tipini kullanırız.

git commit -m "fix(cart): Sepete aynı ürün birden fazla eklenince miktar hatası düzeltildi"

Bu örnekte, commit'in bir hata düzeltmesi olduğunu ve sepet modülündeki spesifik bir miktar hatasını hedef aldığını hemen anlayabiliriz. Bu sayede, gelecekte bu hata tekrar ortaya çıktığında veya benzer bir sorun yaşandığında, ilgili commit'i bulmak çok daha kolay olacaktır.

Örnek 3: Dokümantasyon Güncellemesi

Sadece README dosyasında bir yazım hatasını düzelttiyseniz:

git commit -m "docs: README.md dosyasındaki yazım hatası düzeltildi"

Bu commit, projenin davranışını veya kodunu etkilemediği için docs tipi ile belirtilir. Böylece, otomatik changelog oluşturucular bu commit'i yeni özellikler veya hata düzeltmeleri listesine dahil etmez.

Detaylı Commit Mesajları ve Gelişmiş Kullanım Senaryoları

Bazen kısa açıklama yetersiz kalabilir ve değişikliğin arkasındaki motivasyonu veya daha fazla detayı açıklamak gerekebilir. İşte burada commit mesajının gövde (body) ve dipnot (footer) kısımları devreye girer. Bu kısımları kullanmak için Git'in interaktif commit özelliğinden yararlanabilir veya çok satırlı bir mesaj girebilirsiniz.

Örnek 4: Gövde (Body) İçeren Commit Mesajı

Bir performans iyileştirmesi yaptığınızı ve bunun neden gerekli olduğunu açıklamak istediğinizi varsayalım. Git commit komutunu parametresiz çalıştırdığınızda, varsayılan metin düzenleyiciniz açılacaktır.

git commit

Açılan düzenleyiciye aşağıdaki gibi bir mesaj girebilirsiniz:

feat(performance): Veritabanı sorguları optimize edildi

Bu değişiklik, ana sayfa yükleme süresini %30 oranında iyileştirmeyi amaçlamaktadır.
Önceki sorgular N+1 sorununa neden oluyordu. Bu commit ile tek bir toplu sorgu
kullanılarak gereksiz veritabanı erişimleri ortadan kaldırıldı.

Analizler:
- Sayfa yükleme süresi: 3.2s -> 2.1s
- Veritabanı bağlantı sayısı: 15 -> 3

Burada gövde kısmı, değişikliğin "nedenini" (performans iyileştirme ihtiyacı) ve "nasılını" (toplu sorgu kullanımı, N+1 sorununun çözümü) detaylandırır. Hatta analiz sonuçlarını bile ekleyerek gelecekteki referanslar için değerli bilgiler sunar.

Örnek 5: Dipnot (Footer) ile Kırıcı Değişiklik (Breaking Change) Bildirimi

Bir API'de geriye dönük uyumlu olmayan bir değişiklik yaptığınızda, bunu açıkça belirtmek hayati önem taşır. Bu, diğer geliştiricilerin kodlarını güncellemesi gerektiğini anlamalarını sağlar ve otomatik sürüm yönetimi araçlarının doğru sürüm artışını yapmasına yardımcı olur.

git commit

Açılan düzenleyiciye aşağıdaki gibi bir mesaj girin:

feat(api): Kullanıcı profil endpoint'i güncellendi

/api/users/{id} endpoint'i artık sadece GET metodu ile çalışıyor.
PUT ve DELETE metotları /api/admin/users/{id} endpoint'ine taşındı
ve admin yetkisi gerektiriyor.

BREAKING CHANGE: Mevcut kullanıcılar için /api/users/{id} endpoint'inin
PUT ve DELETE çağrıları başarısız olacaktır. Lütfen yeni endpoint'i
ve yetkilendirme kurallarını kontrol edin.

BREAKING CHANGE: dipnotu, bu commit'in büyük bir uyumsuzluk içerdiğini açıkça belirtir. Bu, otomatik araçların projenin ana (major) sürümünü yükseltmesini tetikleyebilir ve diğer geliştiricilere gerekli güncellemeleri yapmaları için önemli bir uyarıdır.

Örnek 6: Dipnot ile Issue Takibi Entegrasyonu

Çoğu projede, görevler veya hatalar Jira, GitHub Issues gibi sistemlerde takip edilir. Bir commit'i belirli bir göreve bağlamak için dipnotları kullanabiliriz:

git commit -m "fix(payment): Ödeme ağ geçidi entegrasyon hatası giderildi

Hata, ağ geçidinden gelen response'ın hatalı parse edilmesi nedeniyle oluşuyordu.
Özellikle 'amount' alanının ondalık kısmı yanlış işleniyordu.

Closes #BUG-456"

Closes #BUG-456 dipnotu, bu commit'in BUG-456 numaralı sorunu kapattığını belirtir. Çoğu issue takip sistemi, bu tür dipnotları otomatik olarak algılar ve commit'i ilgili issue ile ilişkilendirir, hatta bazıları issue'yu otomatik olarak kapatır.

Conventional Commits'i adım adım uygulamak, başlangıçta biraz daha fazla düşünme gerektirse de, kısa sürede geliştirme ekibiniz için vazgeçilmez bir pratik haline gelecektir. Anlaşılır bir Git geçmişi, daha az yanlış anlaşılma, daha hızlı hata ayıklama ve daha verimli otomatik süreçler anlamına gelir. Bu basit ama güçlü yapı, projenizin sürdürülebilirliğini ve kalitesini önemli ölçüde artıracaktır.

Conventional Commits Kullanımının Pratik Faydaları Nelerdir?

Conventional Commits'in sağladığı faydalar sadece güzel görünümlü bir Git geçmişi oluşturmaktan çok daha fazlasını kapsar. Bu standart, yazılım geliştirme döngüsünün her aşamasında somut iyileştirmeler sunar. Bu bölümde, Conventional Commits'in pratik faydalarını gerçek dünya senaryoları üzerinden inceleyeceğiz.

Otomatik Changelog Oluşturma ve Sürüm Yönetimi

En önemli faydalardan biri, otomatik changelog (değişiklik günlüğü) oluşturma ve sürüm yönetimi (semantic versioning) yeteneğidir. Manuel olarak değişiklik günlüğü hazırlamak, zaman alıcı, hataya açık ve genellikle eksik bir süreçtir. Conventional Commits sayesinde, bu süreç tamamen otomatikleştirilebilir.

Vaka Analizi: Büyük Bir Açık Kaynak Kütüphanesi

Diyelim ki, JavaScript için popüler bir UI kütüphanesi geliştiriyorsunuz. Her yeni sürümde, kullanıcıların hangi yeni özelliklerin eklendiğini, hangi hataların düzeltildiğini ve hangi kırıcı değişikliklerin yapıldığını bilmesi gerekir. Conventional Commits kullanmadan önce, geliştiriciler her sürüm öncesi tüm commit geçmişini manuel olarak gözden geçirip bir changelog yazmak zorundaydı. Bu, saatler süren bir işti ve sıklıkla önemli detaylar atlanabiliyordu.

Conventional Commits'e geçtikten sonra, ekip semantic-release gibi bir araç kullanmaya başladı. Bu araç, Git geçmişindeki Conventional Commit mesajlarını tarayarak:

  • feat tipli commit'leri algılayıp "Yeni Özellikler" bölümüne ekler.
  • fix tipli commit'leri "Hata Düzeltmeleri" bölümüne ekler.
  • BREAKING CHANGE içeren dipnotları fark edip "Kırıcı Değişiklikler" bölümünü oluşturur ve gerekli uyarıları ekler.
  • Bu commit tiplerine göre otomatik olarak Semantic Versioning kurallarına uygun (örn. 1.0.0'dan 1.1.0'a veya 2.0.0'a) bir sürüm numarası belirler.

Böylece, her yeni commit merge edildiğinde veya belirli bir dalda tetiklendiğinde, changelog otomatik olarak güncellenir ve yeni bir sürüm etiketi (tag) oluşturulur. Bu, hem zaman kazandırır hem de kullanıcıların projedeki gelişmeleri şeffaf bir şekilde takip etmesini sağlar. Ayrıca, geliştiricilerin sadece kod yazmaya odaklanmasını sağlayarak verimliliği artırır.

Geliştirici Deneyimini Nasıl İyileştirir? (Kod İncelemesi, Hata Ayıklama)

Conventional Commits, geliştiricilerin günlük iş akışını doğrudan etkileyerek daha sorunsuz bir deneyim sunar.

Vaka Analizi: Yeni Bir Geliştiricinin Onboarding Süreci

Bir yazılım firmasına yeni katılan bir geliştiricinin, mevcut bir projenin kod tabanına alışması genellikle zaman alır. Projenin geçmişini anlamak, hangi kararların neden alındığını bilmek, bu sürecin kritik bir parçasıdır. Kötü commit mesajları olan bir projede, yeni geliştirici git log çıktısına baktığında sadece "güncellemeler", "düzeltmeler" gibi belirsiz girdilerle karşılaşır. Bu durum, onu kodun her satırını tek tek okumaya ve geçmişi çözmeye zorlar.

Conventional Commits kullanan bir projede ise durum farklıdır. Yeni geliştirici git log komutunu çalıştırdığında, temiz ve yapılandırılmış bir geçmişle karşılaşır:

feat(dashboard): Yönetici paneline istatistik widget'ı eklendi
fix(auth): Token yenileme hatası düzeltildi
docs: API dokümantasyonu güncellendi
feat(search): Gelişmiş filtreleme seçenekleri

Bu çıktı sayesinde, yeni geliştirici projenin ana özelliklerini, yapılan hata düzeltmelerini ve genel gelişim yönünü çok daha hızlı kavrar. Hangi commit'in ne yaptığını kolayca anladığı için, belirli bir özelliği veya modülü incelemesi gerektiğinde ilgili commit'leri hızla bulabilir. Bu da onboarding sürecini önemli ölçüde kısaltır ve yeni ekip üyesinin daha çabuk üretken olmasını sağlar.

Kod İncelemeleri (Code Reviews):

Kod incelemeleri, yazılım kalitesini artırmak için hayati öneme sahiptir. Conventional Commits, incelemeyi yapan geliştiricinin işini kolaylaştırır. Bir Pull Request (Çekme İsteği) incelerken, commit mesajlarının standart olması, değişikliklerin amacını net bir şekilde anlamaya yardımcı olur. Örneğin, bir feat(user-profile): ile başlayan commit mesajı, sadece kod değişikliklerine bakarak anlamaya çalışmaktan çok daha hızlı bir şekilde değişikliğin "kullanıcı profil modülüne yeni bir özellik eklediğini" gösterir. Bu, incelemecinin kodu daha doğru bir bağlamda değerlendirmesini sağlar ve daha odaklı geri bildirimler vermesine olanak tanır.

Hata Ayıklama (Debugging):

Bir hata tespit edildiğinde, Conventional Commits ile hata ayıklama süreci hızlanır. git bisect gibi araçlar, hata tanıtan commit'i bulmak için kullanılır. Eğer commit mesajları düzensizse, bu araç sadece hangi commit'in hatayı içerdiğini söyler, ancak o commit'in amacını anlamak için yine kodu incelemek gerekir. Conventional Commits ile, fix(payment): veya feat(email): gibi mesajlar, hatanın olası kökenini ve ne zaman, hangi modülde ortaya çıktığını çok daha net bir şekilde gösterir. Bu, sorunun kaynağını hızla izole etmeye ve daha verimli bir şekilde çözüme ulaşmaya yardımcı olur.

Kısacası, Conventional Commits, sadece teknik bir standart değil, aynı zamanda geliştirici deneyimini zenginleştiren, ekip işbirliğini artıran ve projenin uzun vadeli sürdürülebilirliğini garantileyen güçlü bir araçtır.

Conventional Commits ile İş Akışınızı Nasıl Geliştirirsiniz?

Conventional Commits'in sadece iyi commit mesajları yazmaktan ibaret olmadığını, aynı zamanda geliştirme iş akışınızı otomatikleştirme ve daha verimli hale getirme potansiyeli taşıdığını görmek önemlidir. Bu bölümde, Conventional Commits'i daha ileri düzeyde kullanarak projelerinizi nasıl güçlendirebileceğinizi, Git hook'ları ve otomatik sürüm yönetimi gibi araçlarla nasıl entegre edebileceğinizi keşfedeceğiz.

Git Hook'ları ile Commit Mesajı Doğrulama

Bir standart belirlemek harikadır, ancak bu standarda uyumu sağlamak ayrı bir zorluktur. İşte tam bu noktada Git hook'ları devreye girer. Git hook'ları, Git olayları (örneğin commit öncesi, commit sonrası) tetiklendiğinde otomatik olarak çalıştırılan scriptlerdir. commit-msg hook'u, bir commit mesajı yazıldıktan sonra ve commit gerçekten kaydedilmeden önce tetiklenir. Bu hook'u kullanarak commit mesajlarının Conventional Commits spesifikasyonuna uygun olup olmadığını kontrol edebiliriz.

Örnek: Basit Bir commit-msg Hook'u

Projenizin .git/hooks/commit-msg yoluna aşağıdaki gibi bir Bash script'i ekleyebilirsiniz. Bu script, commit mesajının başlangıcının belirli bir kalıba uyup uymadığını kontrol eder.

#!/bin/sh

# Commit mesajı dosyasının yolu
COMMIT_MSG_FILE=$1

# Conventional Commits desenini kontrol et
# Örnek: feat(scope): description
# veya fix(scope): description
# Regex: ^(feat|fix|docs|style|refactor|test|chore|build|ci)(\([a-zA-Z0-9_\-]+\))?: [A-Z].*$
if ! grep -Eq '^(feat|fix|docs|style|refactor|test|chore|build|ci)(\([a-zA-Z0-9_\-]+\))?: [^[:space:]].*' "$COMMIT_MSG_FILE"; then
  echo "HATA: Conventional Commits standardına uymayan commit mesajı!"
  echo "Lütfen şu formatı kullanın: (): "
  echo "Örnekler:"
  echo "  feat(auth): Yeni kullanıcı kaydı eklendi"
  echo "  fix(bug): Giriş sayfasındaki hata düzeltildi"
  echo "Geçerli tipler: feat, fix, docs, style, refactor, test, chore, build, ci"
  exit 1
fi

Bu script'i çalıştırılabilir hale getirmeyi unutmayın: chmod +x .git/hooks/commit-msg.

Bu basit hook, geliştiricilerin yanlış formatta commit mesajları göndermesini engeller. Daha gelişmiş doğrulama için commitlint gibi npm paketleri kullanılabilir. commitlint, bir yapılandırma dosyası aracılığıyla (örn. .commitlintrc.js) çok daha detaylı kurallar (açıklama uzunluğu, kapsam tipleri vb.) tanımlamanıza olanak tanır ve genellikle husky gibi araçlarla birlikte kullanılır.


// package.json
{
  "name": "my-project",
  "version": "1.0.0",
  "devDependencies": {
    "@commitlint/cli": "^17.0.0",
    "@commitlint/config-conventional": "^17.0.0",
    "husky": "^8.0.0"
  },
  "scripts": {
    "prepare": "husky install"
  }
}


// .commitlintrc.js
module.exports = {
extends: ['@commitlint/config-conventional'],
rules: {
'type-enum': [
2,
'always',
['feat', 'fix', 'docs', 'style', 'refactor', 'test', 'chore', 'build', 'ci']
],
'subject-full-stop': [2, 'never', '.'],
'subject-case': [2, 'always', 'sentence-case']
}
};


# .husky/commit-msg
npx --no -- commitlint --edit ${1}

Bu kurulum, her commit öncesinde mesajın commitlint tarafından kontrol edilmesini sağlar, böylece herkesin standarda uyması garanti altına alınır.

Otomatik Sürüm Yönetimi ve Yayınlama Süreçleri

Conventional Commits'in en güçlü yönlerinden biri, otomatik sürüm yönetimi ve yayınlama (release) süreçlerini mümkün kılmasıdır. semantic-release gibi araçlar, bu standarttan en iyi şekilde yararlanır.

Vaka Analizi: Modern CI/CD Ortamı

Gelişmiş bir CI/CD (Continuous Integration/Continuous Delivery) ortamına sahip bir web uygulaması projesi düşünelim. Daha önce, her yayın (release) öncesi manuel olarak sürüm numarası artırılıyor, changelog yazılıyor ve paketler dağıtılıyordu. Bu süreç, zaman alıcı ve hatalara açıktı.

Conventional Commits'i benimseyip semantic-release'i entegre ettikten sonra, yayınlama süreci büyük ölçüde otomatize edildi. Artık bir geliştirici ana dala (main/master) bir commit gönderdiğinde:

  1. CI/CD boru hattı çalışır.
  2. semantic-release aracı, en son yayınlanan sürümden bu yana yapılan tüm Conventional Commit mesajlarını analiz eder.
  3. Eğer fix tipli commit'ler varsa, bir patch sürümü (örn. 1.0.0'dan 1.0.1'e) artırılması gerektiğini anlar.
  4. Eğer feat tipli commit'ler varsa, bir minor sürümü (örn. 1.0.0'dan 1.1.0'a) artırılması gerektiğini anlar.
  5. Eğer BREAKING CHANGE içeren commit'ler varsa, bir major sürümü (örn. 1.0.0'dan 2.0.0'a) artırılması gerektiğini anlar.
  6. Yeni sürüm numarası belirlendikten sonra, otomatik olarak bir Git etiketi (tag) oluşturulur (örn. v1.1.0).
  7. Yeni bir changelog dosyası (veya mevcut changelog güncellenir) oluşturulur.
  8. Oluşturulan paketler (örn. npm, Docker imajları) otomatik olarak dağıtım platformlarına yüklenir.
  9. Gerekirse, GitHub Releases veya Slack gibi platformlara bildirimler gönderilir.

Bu otomasyon, yayınlama sürecini hızlandırır, insan hatasını minimize eder ve geliştiricilerin daha çok kod yazmaya odaklanmasını sağlar. Projenin sürüm geçmişi her zaman tutarlı ve güncel kalır. Conventional Commits, bir projenin büyümesiyle ortaya çıkan karmaşıklığı yönetmek ve sürdürülebilirliği sağlamak için vazgeçilmez bir stratejidir.

Conventional Commit Tipi Açıklama Sürüm Artışı (Semantic Versioning)
feat Yeni bir özellik ekler Minor (örn. 1.0.0 -> 1.1.0)
fix Bir hatayı düzeltir Patch (örn. 1.0.0 -> 1.0.1)
BREAKING CHANGE Geriye dönük uyumsuz bir değişiklik Major (örn. 1.0.0 -> 2.0.0)
docs, style, refactor, test, chore, vb. Davranışsal olmayan değişiklikler Yok (Sadece yeniden yayınlama)

Bu tablo, Conventional Commits tipleri ile Semantic Versioning arasındaki ilişkiyi özetlemektedir. Mobil cihazlarda da okunabilirliği artırmak için CSS medya sorguları kullanılarak düzenlenmiştir.

Conventional Commits: Daha Temiz Bir Kod Geçmişi İçin Anahtarınız

Yazılım geliştirme, sürekli bir değişim ve gelişim sürecidir. Bu sürecin her adımında alınan kararlar, yapılan değişiklikler ve çözülen sorunlar, projenin Git geçmişinde bir iz bırakır. Conventional Commits, bu izi sadece bir kayıt olmaktan çıkarıp, projenizin yaşayan bir belgesi haline getirir. Makale boyunca gördüğümüz gibi, kötü ve anlamsız commit mesajlarının yol açtığı iletişim kopuklukları, zorlu hata ayıklama süreçleri ve manuel sürüm yönetimi gibi problemler, Conventional Commits'in sağladığı standartlaşma ile kolayca aşılabilir.

Conventional Commits, her commit mesajına anlamlı bir yapı ve net bir amaç kazandırır. type, scope, description, body ve footer gibi bileşenler sayesinde, yapılan her değişikliğin ne olduğunu, neden yapıldığını ve hangi etkilere sahip olduğunu açıkça ifade edebiliriz. Bu şeffaflık, ekip üyeleri arasındaki işbirliğini artırır, kod incelemelerini hızlandırır ve yeni katılan geliştiricilerin projeye adaptasyonunu kolaylaştırır.

Dahası, Conventional Commits sadece insan odaklı bir çözüm değildir; otomatik araçlarla entegrasyonu sayesinde geliştirme süreçlerini kökten iyileştirir. Otomatik changelog oluşturma, Semantic Versioning kurallarına uygun sürüm yükseltmeleri ve CI/CD boru hatlarında sorunsuz entegrasyon, bu yaklaşımın sunduğu en büyük avantajlardandır. Git hook'ları ve commitlint gibi araçlarla bu standardın zorunlu kılınması, projenin uzun vadeli sürdürülebilirliği ve kalitesi için kritik bir adımdır.

Özetle, Conventional Commits, daha disiplinli bir geliştirme kültürü oluşturur, teknik borcu azaltır ve ekibinizin daha verimli çalışmasına olanak tanır. Kötü commit mesajlarına veda etmek, projenize yapabileceğiniz en iyi yatırımlardan biridir. Bu makaledeki rehberliği takip ederek, siz de bugün projenizin Git geçmişini temizlemeye ve modernize etmeye başlayabilirsiniz. Unutmayın, temiz bir Git geçmişi, daha sağlıklı bir kod tabanı ve daha mutlu bir ekip demektir.

Sıkça Sorulan Sorular (SSS)

  • Conventional Commits kullanmak projem için zorunlu mu?

    Hayır, Conventional Commits bir spesifikasyondur ve kullanımı zorunlu değildir. Ancak, projenizin büyüklüğü, ekip üyelerinin sayısı ve sürdürülebilirlik hedefleriniz doğrultusunda şiddetle tavsiye edilir. Özellikle açık kaynak projelerde veya büyük ekiplerde standartlaşma, işbirliğini ve otomatik süreçleri inanılmaz derecede kolaylaştırır.

  • Mevcut bir projede Conventional Commits'e nasıl geçiş yapabilirim?

    Küçük adımlarla başlayın. Öncelikle ekibinizi bu standardın faydaları hakkında bilgilendirin ve birlikte hangi type ve scope değerlerini kullanacağınıza karar verin. Yeni commit'lerden itibaren Conventional Commits yapısını uygulamaya başlayın. Mevcut Git geçmişinizi baştan yazmak genellikle gerekli değildir, ancak kritik projelerde git rebase -i ile eski commit'leri düzenleme seçeneği de bulunmaktadır. Doğrulama araçlarını (örn. commitlint) yavaş yavaş devreye alabilirsiniz.

  • Tüm commit tiplerini (feat, fix, docs vb.) ezberlemem gerekiyor mu?

    Hayır, tüm tipleri ezberlemenize gerek yok. En yaygın olanlar feat ve fix'tir ve bunlar genellikle projenizin %80-90'ını kapsar. Geri kalan tipler, özel durumlar için kullanılır ve zamanla öğrenebilirsiniz. Önemli olan, tutarlı bir şekilde ana tipleri kullanmak ve commit mesajının amacını net bir şekilde ifade etmektir.

  • Hangi araçlar Conventional Commits'i destekler veya zorunlu kılmama yardımcı olur?

    Pek çok araç Conventional Commits ile entegre çalışır. Bunlardan bazıları:

    • commitlint: Commit mesajlarını doğrulamak için bir araç. Git hook'ları (özellikle husky ile) ile entegre çalışır.
    • semantic-release: Conventional Commits'e dayalı olarak otomatik sürüm oluşturma, yayınlama ve changelog üretme aracı.
    • standard-version: Benzer bir otomatik sürüm ve changelog oluşturma aracı.
    • GitHub Actions, GitLab CI/CD: Bu platformlar üzerinde kendi doğrulama ve yayınlama adımlarınızı kolayca kurabilirsiniz.
  • Conventional Commits sadece Git için mi geçerli?

    Conventional Commits spesifikasyonu, Git gibi dağıtık sürüm kontrol sistemleri için tasarlanmıştır ancak prensipleri diğer VCS'ler veya hatta genel proje yönetiminde de uygulanabilir. Temel fikir, değişikliklerin amacını standardize etmek ve otomatikleştirilebilir bir format sunmaktır. Bu prensip, kullanıldığı her yerde fayda sağlayacaktır.

Yorumlar
İçeriği beğendiniz mi? Bir tartışma başlatın veya görüşlerinizi paylaşın.
Yorum Yaz

Bir yanıt yazın

E-posta adresiniz yayınlanmayacak. Gerekli alanlar * ile işaretlenmişlerdir

E-posta Bülteni
Yazılım Topluluğuna Katılın
En son güncellemeleri, yaratıcı ipuçlarını ve özel kaynakları doğrudan e-posta kutunuza alın. Tasarım ve inovasyonun geleceğini birlikte keşfedelim.