LibGit2

LibGit2.Buffer

libgit2'den veri dışa aktarmak için bir veri tamponu. git_buf yapısıyla eşleşir.

LibGit2'den veri alırken, tipik bir kullanım şöyle görünür:

buf_ref = Ref(Buffer())
@check ccall(..., (Ptr{Buffer},), buf_ref)
# buf_ref üzerinde işlem
free(buf_ref)

Özellikle, Ref nesnesi üzerinde daha sonra LibGit2.free çağrılması gerektiğine dikkat edin.

LibGit2.CheckoutOptions

git_checkout_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: Kullanımda olan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• checkout_strategy: Çatışmaların nasıl ele alınacağını ve dosyaların zorla kontrol edilip edilmeyeceğini veya eksik dosyaların yeniden oluşturulup oluşturulmayacağını belirler.
• disable_filters: Sıfırdan farklıysa, CLRF gibi filtreleri uygulamayın (UNIX ve DOS arasındaki dosya satır sonlarını dönüştürmek için).
• dir_mode: Kontrol sırasında yer alan herhangi bir dizin için okuma/yazma/erişim modu. Varsayılan 0755'tir.
• file_mode: Kontrol sırasında yer alan herhangi bir dosya için okuma/yazma/erişim modu. Varsayılan 0755 veya 0644, blob'a bağlı olarak.
• file_open_flags: Kontrol sırasında herhangi bir dosyayı açmak için kullanılan bit bayrakları.
• notify_flags: Kullanıcının hangi tür çatışmalar hakkında bilgilendirilmesi gerektiği için bayraklar.
• notify_cb: Bir kontrol çatışması meydana geldiğinde kullanıcıyı bilgilendirmek için isteğe bağlı bir geri çağırma fonksiyonu. Bu fonksiyon sıfırdan farklı bir değer dönerse, kontrol iptal edilecektir.
• notify_payload: Bilgilendirme geri çağırma fonksiyonu için yük.
• progress_cb: Kontrol ilerlemesini göstermek için isteğe bağlı bir geri çağırma fonksiyonu.
• progress_payload: İlerleme geri çağırması için yük.
• paths: Boş değilse, kontrol sırasında hangi yolların aranacağını tanımlar. Boşsa, kontrol deposundaki tüm dosyalar üzerinde gerçekleşecektir.
• baseline: workdir için beklenen içerik, bir GitTree (işaretçi) içinde yakalanmıştır. Varsayılan, HEAD'deki ağacın durumudur.
• baseline_index: workdir için beklenen içerik, bir GitIndex (işaretçi) içinde yakalanmıştır. Varsayılan, HEAD'deki indeksin durumudur.
• target_directory: Boş değilse, workdir yerine bu dizine kontrol yapın.
• ancestor_label: Çatışma durumunda, ortak ata tarafının adı.
• our_label: Çatışma durumunda, "bizim" tarafımızın adı.
• their_label: Çatışma durumunda, "onların" tarafının adı.
• perfdata_cb: Performans verilerini göstermek için isteğe bağlı bir geri çağırma fonksiyonu.
• perfdata_payload: Performans geri çağırması için yük.

LibGit2.CloneOptions

git_clone_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: Kullanımda olan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• checkout_opts: Klonlama işlemi sırasında uzaktan checkout yapmak için seçenekler.
• fetch_opts: Klonlama işlemi sırasında uzaktan ön-checkout fetch yapmak için seçenekler.
• bare: 0 ise, tam uzaktan depo klonlanır. Sıfırdan farklı bir değer ise, kaynak dosyaların yerel kopyası olmayan bir bare klonlama yapılır ve gitdir ile workdir aynı olur.
• localclone: Yerel bir nesne veritabanını klonlayıp klonlamayacağını veya bir fetch yapıp yapmayacağını belirten bayrak. Varsayılan, git'in karar vermesine izin vermektir. Yerel bir klon için git-bilgilendirilmiş taşıma kullanılmayacak, ancak file:// ile başlayan URL'ler için kullanılacaktır.
• checkout_branch: Checkout yapılacak dalın adı. Boş bir dize ise, uzaktaki varsayılan dal checkout yapılacaktır.
• repository_cb: Klonlama işleminin yapıldığı yeni depoyu oluşturmak için kullanılacak isteğe bağlı geri çağırma.
• repository_cb_payload: Depo geri çağırması için yük.
• remote_cb: Klonlama işlemi yapılmadan önce GitRemote oluşturmak için kullanılan isteğe bağlı geri çağırma.
• remote_cb_payload: Uzak geri çağırması için yük.

LibGit2.DescribeOptions

git_describe_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: bu yapının kullanımda olan versiyonu, eğer bu daha sonra değişirse. Şu anda her zaman 1.
• max_candidates_tags: bir komiti tanımlamak için refs/tags içindeki en son bu kadar çok etiketi dikkate al. Varsayılan olarak 10'dur (yani en son 10 etiketi incelemek için).
• describe_strategy: refs/tags içindeki tüm girişleri dikkate alıp almayacağı (eşdeğer olarak git-describe --tags) veya refs/ içindeki tüm girişleri (eşdeğer olarak git-describe --all). Varsayılan olarak yalnızca anotasyonlu etiketler gösterilir. Eğer Consts.DESCRIBE_TAGS geçirilirse, anotasyonlu veya anotasyonsuz tüm etiketler dikkate alınacaktır. Eğer Consts.DESCRIBE_ALL geçirilirse, refs/ içindeki herhangi bir ref dikkate alınacaktır.
• pattern: yalnızca pattern ile eşleşen etiketleri dikkate al. Glob genişletmesini destekler.
• only_follow_first_parent: eşleşen bir referanstan tanımlanan nesneye olan mesafeyi bulurken, yalnızca ilk ebeveynden olan mesafeyi dikkate al.
• show_commit_oid_as_fallback: eğer bir komiti tanımlayan eşleşen bir referans bulunamazsa, bir hata fırlatmak yerine komitin GitHash değerini göster. (varsayılan davranış).

LibGit2.DescribeFormatOptions

git_describe_format_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: kullanılan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• abbreviated_size: kullanılacak kısaltılmış GitHash'in boyutu için alt sınır, varsayılan olarak 7.
• always_use_long_format: kısa bir format kullanılabilse bile, dizeler için uzun formatı kullanmak üzere 1 olarak ayarlanır.
• dirty_suffix: ayarlandığında, bu, workdir kirli olduğunda açıklama dizesinin sonuna eklenecektir.

LibGit2.DiffDelta

Bir girişteki değişikliklerin tanımı. git_diff_delta yapısıyla eşleşir.

Alanlar şunları temsil eder:

• status: Dosyanın eklenip/ değiştirilip/ silinmediğini belirten Consts.DELTA_STATUS'dan biri.
• flags: Delta ve her iki taraftaki nesneler için bayraklar. Dosyaların ikisini de ikili/metin olarak ele alınıp alınmayacağını, her iki tarafta da mevcut olup olmadıklarını ve nesne kimliklerinin doğru olduğunun bilinip bilinmediğini belirler.
• similarity: Bir dosyanın yeniden adlandırılıp adlandırılmadığını veya kopyalanıp kopyalanmadığını belirtmek için kullanılır.
• nfiles: Delta içindeki dosya sayısı (örneğin, delta bir alt modül taahhüt kimliği üzerinde çalıştırıldıysa, birden fazla dosya içerebilir).
• old_file: Değişikliklerden önceki dosya(lar) hakkında bilgi içeren bir DiffFile.
• new_file: Değişikliklerden sonraki dosya(lar) hakkında bilgi içeren bir DiffFile.

LibGit2.DiffFile

Delta'nın bir tarafının tanımı. git_diff_file yapısıyla eşleşir.

Alanlar şunları temsil eder:

• id: farktaki öğenin GitHash. Eğer öğe bu farkın bu tarafında boşsa (örneğin, bir dosyanın kaldırılmasına dair bir farksa), bu GitHash(0) olacaktır.
• path: depo çalışma dizinine göre öğeye giden NULL ile sonlandırılmış bir yol.
• size: öğenin boyutu bayt cinsinden.
• flags: git_diff_flag_t bayraklarının bir kombinasyonu. Bu tam sayının i'nci biti i'nci bayrağı ayarlar.
• mode: öğe için stat modu.
• id_abbrev: yalnızca LibGit2 sürümleri 0.25.0 veya daha yenisi için mevcuttur. string kullanılarak dönüştürüldüğünde id alanının uzunluğu. Genellikle OID_HEXSZ (40) ile eşittir.

LibGit2.DiffOptionsStruct

git_diff_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: kullanılan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• flags: hangi dosyaların diff'te görüneceğini kontrol eden bayraklar. Varsayılan DIFF_NORMAL'dır.
• ignore_submodules: alt modüllerdeki dosyaları kontrol edip etmeyeceği. Varsayılan SUBMODULE_IGNORE_UNSPECIFIED'dir, bu da alt modülün yapılandırmasının diff'te görünüp görünmeyeceğini kontrol edeceği anlamına gelir.
• pathspec: diff'e dahil edilecek dosyaların yolu. Varsayılan, depodaki tüm dosyaları kullanmaktır.
• notify_cb: dosya delta'ları eklendikçe diff'teki değişiklikleri kullanıcıya bildirecek isteğe bağlı geri çağırma.
• progress_cb: diff ilerlemesini gösterecek isteğe bağlı geri çağırma. Sadece libgit2'nin en az 0.24.0 sürümünde geçerlidir.
• payload: notify_cb ve progress_cb'ye iletilecek yük.
• context_lines: bir hunk'ın kenarlarını tanımlamak için kullanılan değişmeyen satır sayısı. Bu, bir hunk'tan önce/sonra gösterilecek satır sayısıdır. Varsayılan 3'tür.
• interhunk_lines: iki ayrı hunk arasında birleştirilmeden önce izin verilen maksimum değişmeyen satır sayısı. Varsayılan 0'dır.
• id_abbrev: yazdırılacak kısaltılmış GitHash uzunluğunu ayarlar. Varsayılan 7'dir.
• max_size: bir blob'un maksimum dosya boyutu. Bu boyuttan büyükse, ikili blob olarak işlenecektir. Varsayılan 512 MB'dir.
• old_prefix: diff'in bir tarafında eski dosyaları yerleştirmek için sanal dosya dizini. Varsayılan "a"dır.
• new_prefix: diff'in bir tarafında yeni dosyaları yerleştirmek için sanal dosya dizini. Varsayılan "b"dir.

LibGit2.FetchHead

Fetch sırasında HEAD hakkında bilgi içerir; bu, fetch edilen dalın adı ve URL'si, HEAD'in oid'si ve fetch edilen HEAD'in yerel olarak birleştirilip birleştirilmediğini içerir.

Alanlar şunları temsil eder:

• name: Fetch head'in yerel referans veritabanındaki adı, örneğin, "refs/heads/master".
• url: Fetch head'in URL'si.
• oid: Fetch head'in ucunun GitHash.
• ismerge: Uzakta yapılan değişikliklerin yerel kopyaya henüz birleştirilip birleştirilmediğini belirten Boolean bayrağı. Eğer true ise, yerel kopya uzak fetch head ile günceldir.

LibGit2.FetchOptions

git_fetch_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: kullanılan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• callbacks: fetch sırasında kullanılacak uzak geri çağrılar.
• prune: fetch'ten sonra bir temizleme yapılıp yapılmayacağı. Varsayılan, GitConfig'ten gelen ayarı kullanmaktır.
• update_fetchhead: fetch'ten sonra FetchHead güncellenip güncellenmeyeceği. Varsayılan, güncellemeyi gerçekleştirmektir, bu normal git davranışıdır.
• download_tags: uzakta bulunan etiketlerin indirilip indirilmeyeceği. Varsayılan, sunucudan zaten indirilen nesneler için etiketleri talep etmektir.
• proxy_opts: bir proxy üzerinden uzak bağlantı kurmak için seçenekler. Sadece 0.25.0 veya daha yeni libgit2 sürümlerinde mevcuttur.
• custom_headers: fetch için gereken ek başlıklar. Sadece 0.24.0 veya daha yeni libgit2 sürümlerinde mevcuttur.

GitAnnotated(repo::GitRepo, commit_id::GitHash)
GitAnnotated(repo::GitRepo, ref::GitReference)
GitAnnotated(repo::GitRepo, fh::FetchHead)
GitAnnotated(repo::GitRepo, committish::AbstractString)

Açıklamalı bir git komiti, nasıl bulunduğu ve nedenine dair bilgi taşır, böylece yeniden temel alma veya birleştirme işlemleri, komitin bağlamı hakkında daha fazla bilgiye sahip olur. Çatışma dosyaları, örneğin, birleştirmedeki çelişen kaynak/hedef dallar hakkında bilgi içerir. Açıklamalı bir komit, örneğin bir FetchHead geçirildiğinde, bir uzak dalın ucuna veya GitReference kullanılarak tanımlanan bir dal başına atıfta bulunabilir.

GitBlame(repo::GitRepo, path::AbstractString; options::BlameOptions=BlameOptions())

path'teki dosya için reponun geçmişinden elde edilen değişiklik bilgilerini kullanarak bir GitBlame nesnesi oluşturur. GitBlame nesnesi, dosyanın hangi parçalarının ne zaman ve kim tarafından değiştirildiğini kaydeder. options, dosyanın içeriğini nasıl ayıracağınızı ve hangi commit'lerin inceleneceğini kontrol eder - daha fazla bilgi için BlameOptions bölümüne bakın.

GitBlob(repo::GitRepo, hash::AbstractGitHash)
GitBlob(repo::GitRepo, spec::AbstractString)

repo tarafından hash/spec ile belirtilen bir GitBlob nesnesi döndürün.

• hash tam (GitHash) veya kısmi (GitShortHash) bir hash'tir.
• spec metinsel bir spesifikasyondur: tam liste için git belgelerine bakın.

GitCommit(repo::GitRepo, hash::AbstractGitHash)
GitCommit(repo::GitRepo, spec::AbstractString)

repo tarafından hash/spec ile belirtilen bir GitCommit nesnesi döndürün.

• hash, tam (GitHash) veya kısmi (GitShortHash) bir hash'tir.
• spec, metinsel bir spesifikasyondur: tam liste için git belgelerine bakın.

GitConfig(path::AbstractString, level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_APP, force::Bool=false)

path üzerindeki dosyadan yapılandırma bilgilerini yükleyerek yeni bir GitConfig oluşturur. level, repo ve force seçenekleri hakkında daha fazla bilgi için addfile bölümüne bakın.

GitConfig(repo::GitRepo)

repo için saklanan yapılandırmayı alır. Eğer repo belirli bir yapılandırma dosyası ayarlanmamışsa, varsayılan git yapılandırması kullanılacaktır.

GitConfig(level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_DEFAULT)

Varsayılan git yapılandırmasını, öncelikli bir yapılandırmaya global ve sistem yapılandırma dosyalarını yükleyerek alın. Bu, belirli bir git deposunun dışındaki varsayılan yapılandırma seçeneklerine erişmek için kullanılabilir.

GitHash

Bir git nesne tanımlayıcısı, sha-1 hash'ine dayanmaktadır. Bir depodaki GitObject'i tanımlamak için kullanılan 20 baytlık bir dizedir (40 onaltılık basamak).

GitObject(repo::GitRepo, hash::AbstractGitHash)
GitObject(repo::GitRepo, spec::AbstractString)

Belirtilen nesneyi (GitCommit, GitBlob, GitTree veya GitTag) repo'dan hash/spec ile belirtilen şekilde döndürün.

• hash, tam (GitHash) veya kısmi (GitShortHash) bir hash'tir.
• spec, tam liste için git belgelerine bakınız.

GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString) -> GitRemote

Bir uzak git deposunu adını ve URL'sini kullanarak arayın. Varsayılan fetch refspec'ini kullanır.

Örnekler

repo = LibGit2.init(repo_path)
remote = LibGit2.GitRemote(repo, "upstream", repo_url)

GitRemote(repo::GitRepo, rmt_name::AbstractString, rmt_url::AbstractString, fetch_spec::AbstractString) -> GitRemote

Bir uzak git deposunu, deponun adı ve URL'si ile birlikte, uzaktan nasıl alınacağına dair spesifikasyonlarla (örneğin, hangi uzak dalın alınacağı) arayın.

Örnekler

repo = LibGit2.init(repo_path)
refspec = "+refs/heads/mybranch:refs/remotes/origin/mybranch"
remote = LibGit2.GitRemote(repo, "upstream", repo_url, refspec)

GitRemoteAnon(repo::GitRepo, url::AbstractString) -> GitRemote

Sadece URL'sini kullanarak bir uzak git deposunu arayın, adını değil.

Örnekler

repo = LibGit2.init(repo_path)
remote = LibGit2.GitRemoteAnon(repo, repo_url)

LibGit2.GitRepo(path::AbstractString)

path'te bir git deposu açar.

LibGit2.GitRepoExt(path::AbstractString, flags::Cuint = Cuint(Consts.REPOSITORY_OPEN_DEFAULT))

path'te bir git deposunu genişletilmiş kontrollerle açar (örneğin, mevcut kullanıcının path'i okumak için özel bir erişim grubunun üyesi olması gerekiyorsa).

GitRevWalker(repo::GitRepo)

Bir GitRevWalker, bir git deposu reponun revizyonları (yani, commit'leri) arasında yürür. Bu, depodaki commit'lerin bir koleksiyonudur ve yineleme ve LibGit2.map ve LibGit2.count çağrılarını destekler (örneğin, LibGit2.count, bir depodaki commit'lerin ne kadarının belirli bir yazar tarafından yapıldığını belirlemek için kullanılabilir).

cnt = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    LibGit2.count((oid,repo)->(oid == commit_oid1), walker, oid=commit_oid1, by=LibGit2.Consts.SORT_TIME)
end

Burada, LibGit2.count, belirli bir GitHash ile yürüyüş boyunca commit'lerin sayısını bulur. GitHash bir commit'e özgü olduğundan, cnt 1 olacaktır.

GitShortHash(hash::GitHash, len::Integer)

Kısa bir git nesne tanımlayıcısıdır; bu, hash'in ilk len onaltılık basamaklarını içeren ve benzersiz olduğunda bir git nesnesini tanımlamak için kullanılabilir (kalan basamaklar göz ardı edilir).

LibGit2.GitSignature

Bu, bir git_signature nesnesine işaret eden bir işaretçi etrafında bir Julia sarmalayıcısıdır.

LibGit2.GitStatus(repo::GitRepo; status_opts=StatusOptions())

Git deposunda repo her dosyanın durumunu (örneğin, dosya değiştirilmiş mi, sahnelenmiş mi, vb.) hakkında bilgi toplar. status_opts, izlenmeyen dosyaları kontrol edip etmeyeceğiniz veya alt modülleri dahil edip etmeyeceğiniz gibi çeşitli seçenekleri ayarlamak için kullanılabilir. Daha fazla bilgi için StatusOptions bakın.

GitTag(repo::GitRepo, hash::AbstractGitHash)
GitTag(repo::GitRepo, spec::AbstractString)

repo tarafından hash/spec ile belirtilen bir GitTag nesnesi döndürün.

• hash tam (GitHash) veya kısmi (GitShortHash) bir hash'tir.
• spec bir metin spesifikasyonudur: tam liste için git belgelerine bakın.

GitTree(repo::GitRepo, hash::AbstractGitHash)
GitTree(repo::GitRepo, spec::AbstractString)

repo tarafından belirtilen hash/spec ile bir GitTree nesnesi döndürün.

• hash, tam (GitHash) veya kısmi (GitShortHash) bir hash'tir.
• spec, metinsel bir spesifikasyondur: tam liste için git belgelerine bakın.

LibGit2.IndexEntry

İndekste bir dosya girişinin bellek içindeki temsili. git_index_entry yapısıyla eşleşir.

LibGit2.IndexTime

git_index_time yapısına karşılık gelir.

LibGit2.BlameOptions

git_blame_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: kullanılan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• flags: Consts.BLAME_NORMAL veya Consts.BLAME_FIRST_PARENT'dan biri (diğer blame bayrakları henüz libgit2 tarafından uygulanmamıştır).
• min_match_characters: bir committe değişikliklerin o commit ile ilişkilendirilmesi için gereken minimum alfa sayısal karakter sayısı. Varsayılan 20'dir. Sadece Consts.BLAME_*_COPIES bayraklarından biri kullanıldığında geçerlidir, bu da libgit2 tarafından henüz uygulanmamıştır.
• newest_commit: değişikliklere bakılacak en yeni commitin GitHash.
• oldest_commit: değişikliklere bakılacak en eski commitin GitHash.
• min_line: blame işlemine başlanacak dosyanın ilk satırı. Varsayılan 1'dir.
• max_line: blame işleminin yapılacağı dosyanın son satırı. Varsayılan 0'dır, bu da dosyanın son satırını ifade eder.

LibGit2.MergeOptions

git_merge_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: yapının kullanımda olan versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.

• flags: birleştirme davranışını tanımlayan bayraklar için bir enum. git_merge_flag_t içinde tanımlanmıştır. Karşılık gelen Julia enum'u GIT_MERGE ve değerleri şunlardır:

  • MERGE_FIND_RENAMES: bir dosyanın ortak ata ile "bizim" veya "onların" tarafı arasında yeniden adlandırılıp adlandırılmadığını tespit et. Bir dosyanın yeniden adlandırıldığı durumlarda birleştirmelere izin verir.
  • MERGE_FAIL_ON_CONFLICT: bir çelişki bulunursa hemen çık, çözmeye çalışmak yerine.
  • MERGE_SKIP_REUC: birleştirmeden kaynaklanan dizinde REUC uzantısını yazma.
  • MERGE_NO_RECURSIVE: birleştirilen commit'lerin birden fazla birleştirme tabanı varsa, bunları yeniden birleştirmeye çalışmak yerine ilkini kullan.

• rename_threshold: iki dosyanın birinin diğerinin yeniden adı olarak kabul edilmesi için ne kadar benzer olması gerektiği. Bu, yüzde benzerliğini ayarlayan bir tam sayıdır. Varsayılan 50'dir.

• target_limit: yeniden adlandırmaları aramak için karşılaştırılacak maksimum dosya sayısı. Varsayılan 200'dür.

• metric: yeniden adlandırma tespiti için iki dosya arasındaki benzerliği belirlemek için kullanılacak isteğe bağlı özel işlev.

• recursion_limit: yeni sanal birleştirme tabanı oluşturmak için gerçekleştirilecek ortak ataların birleştirme sayısında üst sınır. Varsayılan sınırsızdır. Bu alan yalnızca 0.24.0'dan daha yeni libgit2 sürümlerinde mevcuttur.

• default_driver: her iki tarafın da değiştiği durumlarda kullanılacak birleştirme sürücüsü. Bu alan yalnızca 0.25.0'dan daha yeni libgit2 sürümlerinde mevcuttur.

• file_favor: text sürücüsü için çelişen dosya içeriklerini nasıl ele alacağınız.

  • MERGE_FILE_FAVOR_NORMAL: birleştirmenin her iki tarafında bir bölümde değişiklik varsa, çelişkiyi git checkout'un birleştirme dosyası oluşturmak için kullanacağı dizinde not edin, kullanıcı daha sonra çelişkileri çözmek için buna başvurabilir. Bu varsayılandır.
  • MERGE_FILE_FAVOR_OURS: birleştirmenin her iki tarafında bir bölümde değişiklik varsa, dizinde "bizim" tarafındaki versiyonu kullan.
  • MERGE_FILE_FAVOR_THEIRS: birleştirmenin her iki tarafında bir bölümde değişiklik varsa, dizinde "onların" tarafındaki versiyonu kullan.
  • MERGE_FILE_FAVOR_UNION: birleştirmenin her iki tarafında bir bölümde değişiklik varsa, dizine konulan dosyada her iki taraftan da her benzersiz satırı dahil et.

• file_flags: dosyaları birleştirme için kılavuzlar.

LibGit2.ProxyOptions

Proxy üzerinden bağlantı kurmak için seçenekler.

git_proxy_options yapısıyla eşleşir.

Alanlar şunları temsil eder:

• version: kullanılan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.

• proxytype: kullanılacak proxy türü için bir enum. git_proxy_t içinde tanımlıdır. Karşılık gelen Julia enum'u GIT_PROXY ve değerleri şunlardır:

  • PROXY_NONE: bağlantıyı bir proxy üzerinden denemeyin.
  • PROXY_AUTO: git yapılandırmasından proxy yapılandırmasını anlamaya çalışın.
  • PROXY_SPECIFIED: bu yapının url alanında verilen URL'yi kullanarak bağlanın.

  Varsayılan, proxy türünü otomatik olarak tespit etmektir.

• url: proxy'nin URL'si.

• credential_cb: uzaktan bağlantı için kimlik doğrulaması gerekiyorsa çağrılacak bir geri çağırma fonksiyonuna işaretçi.

• certificate_cb: sertifika doğrulaması başarısız olursa çağrılacak bir geri çağırma fonksiyonuna işaretçi. Bu, kullanıcının bağlantıya devam edip etmeyeceğine karar vermesini sağlar. Fonksiyon 1 dönerse, bağlantıya izin verilecektir. 0 dönerse, bağlantıya izin verilmeyecektir. Hata döndürmek için negatif bir değer kullanılabilir.

• payload: iki geri çağırma fonksiyonuna sağlanacak yük.

Örnekler

julia> fo = LibGit2.FetchOptions(
           proxy_opts = LibGit2.ProxyOptions(url = Cstring("https://my_proxy_url.com")))

julia> fetch(remote, "master", options=fo)

LibGit2.PushOptions

git_push_options yapısına karşılık gelir.

Alanlar şunları temsil eder:

• version: kullanılan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• parallelism: bir paket dosyası oluşturulması gerekiyorsa, bu değişken paket oluşturucu tarafından başlatılacak işçi iş parçacıklarının sayısını ayarlar. 0 ise, paket oluşturucu kullanılacak iş parçacığı sayısını otomatik olarak ayarlayacaktır. Varsayılan 1'dir.
• callbacks: itme işlemi için kullanılacak geri çağırmalar (örneğin, uzak ile kimlik doğrulama için).
• proxy_opts: yalnızca LibGit2 sürümü 0.25.0 veya daha büyükse geçerlidir. Uzak ile iletişim kurmak için bir proxy kullanma seçeneklerini ayarlar. Daha fazla bilgi için ProxyOptions bakın.
• custom_headers: yalnızca LibGit2 sürümü 0.24.0 veya daha büyükse geçerlidir. İtme işlemi için gereken ek başlıklar.

LibGit2.RebaseOperation

Rebase sırasında gerçekleştirilecek tek bir talimat/işlemi tanımlar. git_rebase_operation yapısıyla eşleşir.

Alanlar şunları temsil eder:

• optype: şu anda gerçekleştirilen rebase işleminin türü. Seçenekler şunlardır:

  • REBASE_OPERATION_PICK: söz konusu commit'i cherry-pick yap.
  • REBASE_OPERATION_REWORD: söz konusu commit'i cherry-pick yap, ancak mesajını istemle yeniden yaz.
  • REBASE_OPERATION_EDIT: söz konusu commit'i cherry-pick yap, ancak kullanıcının commit'in içeriğini ve mesajını düzenlemesine izin ver.
  • REBASE_OPERATION_SQUASH: söz konusu commit'i önceki commit'e squash yap. İki commit'in mesajları birleştirilecektir.
  • REBASE_OPERATION_FIXUP: söz konusu commit'i önceki commit'e squash yap. Sadece önceki commit'in mesajı kullanılacaktır.
  • REBASE_OPERATION_EXEC: bir commit'i cherry-pick yapma. Bir komut çalıştır ve komut başarılı bir şekilde çıkarsa devam et.

• id: bu rebase adımında üzerinde çalışılan commit'in GitHash.

• exec: REBASE_OPERATION_EXEC kullanılıyorsa, bu adımda çalıştırılacak komut (örneğin, her commit'ten sonra test paketini çalıştırmak).

LibGit2.RebaseOptions

git_rebase_options yapısını karşılar.

Alanlar şunları temsil eder:

• version: kullanılan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• quiet: rebase ile ilgilenen/çalışan diğer git istemcilerine rebase'in "sessizce" yapılması gerektiğini bildirir. Eşdüzgünlük için kullanılır. Varsayılan 1'dir.
• inmemory: bellek içi bir rebase başlatır. Rebase üzerinde çalışan çağrıcılar adımları geçebilir ve değişiklikleri kaydedebilir, ancak HEAD'i geri alıp depoyu güncelleyemez. workdir değiştirilmez. Sadece 0.24.0 veya daha yeni libgit2 sürümlerinde mevcuttur.
• rewrite_notes_ref: rebase tamamlandığında commit notlarını yeniden yazmak için kullanılacak notların referansının adı.
• merge_opts: her rebase adımında ağaçların nasıl birleştirileceğini kontrol eden birleştirme seçenekleri. Sadece 0.24.0 veya daha yeni libgit2 sürümlerinde mevcuttur.
• checkout_opts: rebase'i başlatırken, adım adım geçerken ve iptal ederken dosyaları yazmak için checkout seçenekleri. Daha fazla bilgi için CheckoutOptions bölümüne bakın.

LibGit2.RemoteCallbacks

Geri çağırma ayarları. git_remote_callbacks yapısıyla eşleşir.

LibGit2.SignatureStruct

Bir eylem imzası (örneğin, taahhüt edenler, etiketleyenler vb.). git_signature yapısıyla eşleşir.

Alanlar şunları temsil eder:

• name: Taahhüt edenin veya taahhütün yazarının tam adı.
• email: Taahhüt eden/yazar ile iletişim kurulabilecek e-posta.
• when: Taahhütün depo içine yazıldığı/taahhüt edildiği zamanı belirten bir TimeStruct.

LibGit2.StatusEntry

HEAD'deki dosya ile indeks arasındaki farkları ve indeks ile çalışma dizini arasındaki farkları sağlar. git_status_entry yapısına karşılık gelir.

Alanlar şunları temsil eder:

• status: dosyanın durum bayraklarını içerir, dosyanın güncel olup olmadığını veya indeks veya çalışma ağacında bir şekilde değiştirilip değiştirilmediğini gösterir.
• head_to_index: HEAD'deki dosya ile indeks arasındaki farkları kapsayan bir DiffDelta işaretçisidir.
• index_to_workdir: indeks ile workdir arasındaki farkları kapsayan bir DiffDelta işaretçisidir.

LibGit2.StatusOptions

git_status_foreach_ext()'in geri çağırmaları nasıl vereceğini kontrol etmek için seçenekler. git_status_opt_t yapısıyla eşleşir.

Alanlar şunları temsil eder:

• version: kullanılan yapının versiyonu, bu daha sonra değişirse. Şu anda her zaman 1.
• show: hangi dosyaların inceleneceği ve hangi sırayla inceleneceği için bir bayrak. Varsayılan Consts.STATUS_SHOW_INDEX_AND_WORKDIR.
• flags: bir durum çağrısında kullanılan geri çağırmaları kontrol etmek için bayraklar.
• pathspec: yol eşleştirmesi için kullanılacak bir dizi yol. Yol eşleştirme davranışı, show ve flags değerlerine bağlı olarak değişecektir.
• baseline, çalışma dizini ve dizin ile karşılaştırma için kullanılacak ağaçtır; varsayılan HEAD'dir.

LibGit2.StrArrayStruct

Bir LibGit2 temsilidir dizi dizeleri. git_strarray yapısıyla eşleşir.

LibGit2'den veri alırken, tipik bir kullanım şöyle görünür:

sa_ref = Ref(StrArrayStruct())
@check ccall(..., (Ptr{StrArrayStruct},), sa_ref)
res = convert(Vector{String}, sa_ref[])
free(sa_ref)

Özellikle, Ref nesnesi üzerinde LibGit2.free çağrısının yapılması gerektiğini unutmayın.

Tersine, LibGit2'ye bir dizi dize geçirirken, genellikle örtük dönüşüme güvenmek en basit yoldur:

strs = String[...]
@check ccall(..., (Ptr{StrArrayStruct},), strs)

Verilerin Julia tarafından tahsis edildiği için free çağrısına gerek olmadığını unutmayın.

LibGit2.TimeStruct

Bir imzadaki zaman. git_time yapısıyla eşleşir.

addfile(cfg::GitConfig, path::AbstractString,
        level::Consts.GIT_CONFIG=Consts.CONFIG_LEVEL_APP,
        repo::Union{GitRepo, Nothing} = nothing,
        force::Bool=false)

Mevcut GitConfig cfg'ye path konumundaki mevcut bir git yapılandırma dosyası ekleyin. Dosya mevcut değilse, oluşturulacaktır.

• level, git yapılandırma öncelik seviyesini ayarlar ve

Consts.GIT_CONFIG tarafından belirlenir.

• repo, koşullu içeriklerin ayrıştırılmasına izin vermek için isteğe bağlı bir depodur.
• force false ise ve verilen öncelik seviyesi için bir yapılandırma zaten mevcutsa,

addfile hata verecektir. force true ise, mevcut yapılandırma path konumundaki dosyadaki ile değiştirilecektir.

add!(repo::GitRepo, files::AbstractString...; flags::Cuint = Consts.INDEX_ADD_DEFAULT)
add!(idx::GitIndex, files::AbstractString...; flags::Cuint = Consts.INDEX_ADD_DEFAULT)

files ile belirtilen yollarla tüm dosyaları idx (veya repo'nun indeksine) ekleyin. Eğer dosya zaten mevcutsa, indeks girişi güncellenecektir. Eğer dosya zaten mevcut değilse, indeksin içine yeni olarak eklenecektir. files, genişletilecek ve eşleşen dosyaların ekleneceği glob desenlerini içerebilir (aşağıda belirtilen INDEX_ADD_DISABLE_PATHSPEC_MATCH ayarı yapılmadığı sürece). Eğer bir dosya göz ardı edilmişse (.gitignore içinde veya yapılandırmada), eklenmeyecek, ancak zaten indeks içinde izleniyorsa, o zaman güncellenecektir. flags anahtar kelime argümanı, göz ardı edilen dosyalarla ilgili davranışı kontrol eden bir bit bayrağı setidir:

• Consts.INDEX_ADD_DEFAULT - yukarıda tanımlanan varsayılan.
• Consts.INDEX_ADD_FORCE - mevcut göz ardı kurallarını dikkate almadan dosyanın indeksine eklenmesini zorlar, eğer zaten göz ardı ediliyorsa bile.
• Consts.INDEX_ADD_CHECK_PATHSPEC - INDEX_ADD_FORCE ile aynı anda kullanılamaz. Diskte mevcut olan files içindeki her dosyanın göz ardı listesinde olmadığını kontrol eder. Eğer dosyalardan biri göz ardı edilmişse, fonksiyon EINVALIDSPEC döndürecektir.
• Consts.INDEX_ADD_DISABLE_PATHSPEC_MATCH - glob eşleştirmeyi kapatır ve yalnızca files içinde belirtilen yollarla tam olarak eşleşen dosyaları indekse ekler.

add_fetch!(repo::GitRepo, rmt::GitRemote, fetch_spec::String)

Belirtilen rmt için bir fetch refspec ekleyin. Bu refspec, hangi dal(lar)ın alınacağına dair bilgileri içerecektir.

Örnekler

julia> LibGit2.add_fetch!(repo, remote, "upstream");

julia> LibGit2.fetch_refspecs(remote)
String["+refs/heads/*:refs/remotes/upstream/*"]

add_push!(repo::GitRepo, rmt::GitRemote, push_spec::String)

Belirtilen rmt için bir push refspec ekleyin. Bu refspec, hangi dal(lar)ın itileceği hakkında bilgi içerecektir.

Örnekler

julia> LibGit2.add_push!(repo, remote, "refs/heads/master");

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, branch);

julia> LibGit2.push_refspecs(remote)
String["refs/heads/master"]

LibGit2.addblob!(repo::GitRepo, path::AbstractString)

path'teki dosyayı okuyun ve bunu repo'nun nesne veritabanına gevşek bir blob olarak ekleyin. Ortaya çıkan blob'un GitHash değerini döndürün.

Örnekler

hash_str = string(commit_oid)
blob_file = joinpath(repo_path, ".git", "objects", hash_str[1:2], hash_str[3:end])
id = LibGit2.addblob!(repo, blob_file)

author(c::GitCommit)

c commitinin yazarının Signature'ını döndürür. Yazar, ilgili dosya(lar)da değişiklik yapan kişidir. Ayrıca bkz. committer.

authors(repo::GitRepo) -> Vector{Signature}

repo deposunun tüm yazarlarını döndürür.

Örnekler

repo = LibGit2.GitRepo(repo_path)
repo_file = open(joinpath(repo_path, test_file), "a")

println(repo_file, commit_msg)
flush(repo_file)
LibGit2.add!(repo, test_file)
sig = LibGit2.Signature("TEST", "TEST@TEST.COM", round(time(), 0), 0)
commit_oid1 = LibGit2.commit(repo, "commit1"; author=sig, committer=sig)
println(repo_file, randstring(10))
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid2 = LibGit2.commit(repo, "commit2"; author=sig, committer=sig)

# [sig, sig] olacak bir Vektör
auths = LibGit2.authors(repo)

branch(repo::GitRepo)

git branch ile eşdeğerdir. Mevcut HEAD'den yeni bir dal oluşturur.

branch!(repo::GitRepo, branch_name::AbstractString, commit::AbstractString=""; kwargs...)

repo deposunda yeni bir git dalı oluşturur. commit, yeni dalın başlangıcı olacak olan, string biçimindeki GitHash dir. Eğer commit boş bir string ise, mevcut HEAD kullanılacaktır.

Anahtar argümanlar şunlardır:

• track::AbstractString="": bu yeni dalın takip etmesi gereken uzak dalın adı, varsa. Boşsa (varsayılan), hiçbir uzak dal takip edilmeyecektir.
• force::Bool=false: eğer true ise, dal oluşturma zorlanacaktır.
• set_head::Bool=true: eğer true ise, dal oluşturma işlemi tamamlandıktan sonra dal başı repo'nun HEAD'i olarak ayarlanacaktır.

git checkout [-b|-B] <branch_name> [<commit>] [--track <track>] ile eşdeğerdir.

Örnekler

repo = LibGit2.GitRepo(repo_path)
LibGit2.branch!(repo, "new_branch", set_head=false)

checkout!(repo::GitRepo, commit::AbstractString=""; force::Bool=true)

Eşdeğer git checkout [-f] --detach <commit>. repo içindeki git commit commit'i (bir GitHash string biçiminde) kontrol et. Eğer force true ise, kontrolü zorla ve mevcut değişiklikleri yok say. Bu, mevcut HEAD'i ayırır.

Örnekler

repo = LibGit2.GitRepo(repo_path)
open(joinpath(LibGit2.path(repo), "file1"), "w") do f
    write(f, "111
")
end
LibGit2.add!(repo, "file1")
commit_oid = LibGit2.commit(repo, "add file1")
open(joinpath(LibGit2.path(repo), "file1"), "w") do f
    write(f, "112
")
end
# force=true olmadan başarısız olur
# çünkü dosyada değişiklikler var
LibGit2.checkout!(repo, string(commit_oid), force=true)

clone(repo_url::AbstractString, repo_path::AbstractString, clone_opts::CloneOptions)

repo_url (uzaktan bir URL veya yerel dosya sisteminde bir yol olabilir) üzerindeki uzaktan depoyu repo_path (yerel dosya sisteminde bir yol olmalıdır) konumuna klonlayın. Klonlama için seçenekler, örneğin, çıplak bir klon yapılıp yapılmayacağı gibi, CloneOptions ile ayarlanır.

Örnekler

repo_url = "https://github.com/JuliaLang/Example.jl"
repo = LibGit2.clone(repo_url, "/home/me/projects/Example")

clone(repo_url::AbstractString, repo_path::AbstractString; kwargs...)

repo_url'da bulunan bir uzak deposunu yerel dosya sistemi konumu repo_path'a klonlayın.

Anahtar argümanlar şunlardır:

• branch::AbstractString="": varsayılan depo dalı (genellikle master) değilse, klonlanacak uzak dal.
• isbare::Bool=false: true ise, uzak depoyu çıplak bir depo olarak klonlayın, bu repo_path'ın kendisini git dizini yapar, repo_path/.git yerine. Bu, bir çalışma ağacının kontrol edilemeyeceği anlamına gelir. Git CLI argümanı --bare rolünü oynar.
• remote_cb::Ptr{Cvoid}=C_NULL: klonlanmadan önce uzak depoyu oluşturmak için kullanılacak bir geri çağırma. C_NULL (varsayılan) ise, uzak deponun oluşturulması için herhangi bir girişimde bulunulmayacak - zaten var olduğu varsayılacaktır.
• credentials::Creds=nothing: özel bir depoya karşı kimlik doğrularken kimlik bilgileri ve/veya ayarlar sağlar.
• callbacks::Callbacks=Callbacks(): kullanıcı tarafından sağlanan geri çağırmalar ve yükler.

git clone [-b <branch>] [--bare] <repo_url> <repo_path> ile eşdeğerdir.

Örnekler

repo_url = "https://github.com/JuliaLang/Example.jl"
repo1 = LibGit2.clone(repo_url, "test_path")
repo2 = LibGit2.clone(repo_url, "test_path", isbare=true)
julia_url = "https://github.com/JuliaLang/julia"
julia_repo = LibGit2.clone(julia_url, "julia_path", branch="release-0.6")

commit(repo::GitRepo, msg::AbstractString; kwargs...) -> GitHash

git_commit_create etrafında bir sarmalayıcı. repo içinde bir commit oluşturur. msg commit mesajıdır. Yeni commit'in OID'sini döndürür.

Anahtar kelime argümanları şunlardır:

• refname::AbstractString=Consts.HEAD_FILE: NULL değilse, yeni commit'e işaret edecek referansın adı. Örneğin, "HEAD" mevcut dalın HEAD'ini günceller. Referans henüz mevcut değilse, oluşturulacaktır.
• author::Signature = Signature(repo) commit'i yazan kişinin bilgilerini içeren bir Signature'dır.
• committer::Signature = Signature(repo) commit'i depoya ekleyen kişinin bilgilerini içeren bir Signature'dır. Mutlaka author ile aynı değildir; örneğin, author bir patch'i committer'a e-posta ile gönderip, committer bunu ekleyebilir.
• tree_id::GitHash = GitHash() commit oluşturmak için kullanılacak bir git ağacıdır; soyunu ve diğer tarihlerle olan ilişkisini gösterir. tree repoya ait olmalıdır.
• parent_ids::Vector{GitHash}=GitHash[] yeni commit için ebeveyn commit'leri olarak kullanılacak GitHash listesi ve boş olabilir. Bir commit, örneğin bir birleştirme commit'i ise birden fazla ebeveyn içerebilir.

LibGit2.commit(rb::GitRebase, sig::GitSignature)

Mevcut yamanın rebase rb'ye sig kullanarak yazar olarak kaydedilmesini sağlar. Eğer commit zaten uygulanmışsa sessizdir.

committer(c::GitCommit)

c commitinin imzacısını döndürür. İmza, author tarafından orijinal olarak yazılan değişiklikleri taahhüt eden kişidir, ancak author ile aynı olmak zorunda değildir; örneğin, author bir yamanın e-postasını bir committer'a gönderirse ve o da bunu taahhüt ederse.

LibGit2.count(f::Function, walker::GitRevWalker; oid::GitHash=GitHash(), by::Cint=Consts.SORT_NONE, rev::Bool=false)

GitRevWalker walker kullanarak, depo tarihindeki her bir commit üzerinde "yürüyerek", f uygulandığında true dönen commit sayısını bulun. Anahtar argümanlar şunlardır: * oid: Yürüyüşe başlamak için commitin GitHash. Varsayılan olarak, push_head! kullanılarak HEAD commit'i ve tüm atalarından başlanır. * by: Sıralama yöntemi. Varsayılan olarak sıralama yapılmaz. Diğer seçenekler, topolojik sıralama (LibGit2.Consts.SORT_TOPOLOGICAL), zamana göre ileri sıralama (LibGit2.Consts.SORT_TIME, en eski önce) veya zamana göre geri sıralama (LibGit2.Consts.SORT_REVERSE, en yeni önce) şeklindedir. * rev: Sıralı düzeni tersine çevirip çevirmeyeceği (örneğin, topolojik sıralama kullanılıyorsa).

Örnekler

cnt = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    LibGit2.count((oid, repo)->(oid == commit_oid1), walker, oid=commit_oid1, by=LibGit2.Consts.SORT_TIME)
end

LibGit2.count, yürüyüş boyunca belirli bir GitHash commit_oid1 ile birlikte commit sayısını bulur, yürüyüşe o commit'ten başlayarak ve zamanla ileriye doğru hareket ederek devam eder. GitHash bir commit'e özgü olduğundan, cnt 1 olacaktır.

counthunks(blame::GitBlame)

Bir dosyada bulunan farklı "hunk" sayısını döndürür. Bir hunk birden fazla satır içerebilir. Bir hunk genellikle birlikte eklenen/değiştirilen/kaldırılan bir dosyanın parçasıdır; örneğin, bir kaynak dosyaya eklenen bir fonksiyon veya daha sonra o fonksiyondan çıkarılan bir iç döngü.

LibGit2.create_branch(repo::GitRepo, bname::AbstractString, commit_obj::GitCommit; force::Bool=false)

repo deposunda bname adıyla yeni bir dal oluşturur ve bu dal commit_obj'a işaret eder (bu, reponun bir parçası olmalıdır). Eğer force true ise, mevcutsa bname adındaki bir dalı üzerine yazar. Eğer force false ise ve zaten bname adında bir dal mevcutsa, bu fonksiyon bir hata fırlatacaktır.

credential_callback(...) -> Cint

Bağlantı protokolüne göre farklı kimlik bilgisi edinme işlevselliği sağlayan bir LibGit2 kimlik bilgisi geri çağırma işlevi. payload_ptr'ın bir LibGit2.CredentialPayload nesnesini içermesi gerekmektedir; bu nesne durum ve ayarları takip edecektir.

allowed_types, hangi kimlik doğrulama yöntemlerinin denenmesi gerektiğini belirten bir bitmask olan LibGit2.Consts.GIT_CREDTYPE değerlerini içerir.

Kimlik bilgisi doğrulaması aşağıdaki sırayla yapılır (destekleniyorsa):

• SSH ajanı
• SSH özel/kamu anahtar çifti
• Kullanıcı adı/parola düz metin

Bir kullanıcıya bir kimlik bilgisi istemi sunulduğunda, istemi iptal etmek için ^D yazarak (control tuşuna basarak ve d tuşuna birlikte basarak) iptal edebilirler.

Not: libgit2 kimlik doğrulama prosedürünün özellikleri nedeniyle, kimlik doğrulama başarısız olduğunda, bu işlev tekrar çağrılır; ancak kimlik doğrulamanın başarılı olup olmadığına dair herhangi bir belirti yoktur. Aynı hatalı kimlik bilgilerini tekrar tekrar kullanmaktan kaçınmak için durumu payload ile takip edeceğiz.

Ek detaylar için LibGit2 kılavuzuna bir sunucuya karşı kimlik doğrulama bakın.

C credentials_callback için işlev işaretçisi

İmza nesnesini döndür. Kullanımdan sonra serbest bırak.

LibGit2.delete_branch(branch::GitReference)

branch tarafından gösterilen dalı siler.

diff_files(repo::GitRepo, branch1::AbstractString, branch2::AbstractString; kwarg...) -> Vector{AbstractString}

Git deposunda repo arasında branch1 ve branch2 dalları arasında hangi dosyaların değiştiğini gösterir.

Anahtar argümanı:

• filter::Set{Consts.DELTA_STATUS}=Set([Consts.DELTA_ADDED, Consts.DELTA_MODIFIED, Consts.DELTA_DELETED])), ve diff için seçenekleri ayarlar. Varsayılan, eklenen, değiştirilen veya silinen dosyaları göstermektir.

Değişen dosyaların yalnızca isimlerini döndürün, içeriklerini değil.

Örnekler

LibGit2.branch!(repo, "branch/a")
LibGit2.branch!(repo, "branch/b")
# repo'ya bir dosya ekle
open(joinpath(LibGit2.path(repo),"file"),"w") do f
    write(f, "hello repo
")
end
LibGit2.add!(repo, "file")
LibGit2.commit(repo, "add file")
# ["file"] döner
filt = Set([LibGit2.Consts.DELTA_ADDED])
files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)
# mevcut dosyalar değiştirilmediği için [] döner
filt = Set([LibGit2.Consts.DELTA_MODIFIED])
files = LibGit2.diff_files(repo, "branch/a", "branch/b", filter=filt)

git diff --name-only --diff-filter=<filter> <branch1> <branch2> ile eşdeğerdir.

entryid(te::GitTreeEntry)

te'ye atıfta bulunan nesnenin GitHash değerini döndürür.

entrytype(te::GitTreeEntry)

te'ye atıfta bulunan nesnenin türünü döndürür. Sonuç, objtype tarafından döndürülen türlerden biri olacaktır, örneğin bir GitTree veya GitBlob.

fetch(rmt::GitRemote, refspecs; options::FetchOptions=FetchOptions(), msg="")

Belirtilen rmt uzak git deposundan refspecs kullanarak hangi uzak dal(lar)ın alınacağını belirleyerek alın. Anahtar kelime argümanları şunlardır:

• options: alım için seçenekleri belirler, örneğin sonrasında temizleyip temizlemeyeceği. Daha fazla bilgi için FetchOptions bölümüne bakın.
• msg: reflog'lara eklemek için bir mesaj.

fetch(repo::GitRepo; kwargs...)

Depo repo'nun yukarı akışından güncellemeleri alır.

Anahtar argümanlar şunlardır:

• remote::AbstractString="origin": repo'dan alınacak olan, adıyla belirtilen uzak. Bu boşsa, URL anonim bir uzak oluşturmak için kullanılacaktır.
• remoteurl::AbstractString="": remote'un URL'si. Belirtilmezse, remote'un verilen adı temel alınarak varsayılacaktır.
• refspecs=AbstractString[]: alımın özelliklerini belirler.
• credentials=nothing: özel bir remote'a karşı kimlik doğrularken kimlik bilgileri ve/veya ayarlar sağlar.
• callbacks=Callbacks(): kullanıcı tarafından sağlanan geri çağırmalar ve yükler.

git fetch [<remoteurl>|<repo>] [<refspecs>] ile eşdeğerdir.

fetchheads(repo::GitRepo) -> Vector{FetchHead}

repo için tüm fetch head'lerin listesini döndürür, her biri FetchHead olarak temsil edilir ve adları, URL'leri ve birleştirme durumları dahil edilir.

Örnekler

julia> fetch_heads = LibGit2.fetchheads(repo);

julia> fetch_heads[1].name
"refs/heads/master"

julia> fetch_heads[1].ismerge
true

julia> fetch_heads[2].name
"refs/heads/test_branch"

julia> fetch_heads[2].ismerge
false

fetch_refspecs(rmt::GitRemote) -> Vector{String}

Belirtilen rmt için fetch refspec'lerini alır. Bu refspec'ler, hangi dal(lar)ın alınacağına dair bilgi içerir.

Örnekler

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.add_fetch!(repo, remote, "upstream");

julia> LibGit2.fetch_refspecs(remote)
String["+refs/heads/*:refs/remotes/upstream/*"]

C işlev işaretçisi fetchhead_foreach_callback için

merge_base(repo::GitRepo, one::AbstractString, two::AbstractString) -> GitHash

one ve two arasındaki ortak bir ata (birleştirme tabanı) bulun. one ve two her ikisi de string biçiminde olabilir. Birleştirme tabanının GitHash'ini döndürün.

merge!(repo::GitRepo; kwargs...) -> Bool

repo üzerindeki bir git birleştirmesi gerçekleştirir, dalgalanan geçmişe sahip olan commit'leri mevcut dal ile birleştirir. Birleştirme başarılı olursa true, aksi takdirde false döner.

Anahtar argümanlar şunlardır:

• committish::AbstractString="": committish içindeki belirtilen commit'leri birleştir.
• branch::AbstractString="": branch dalını ve mevcut dal ile ayrıldığı andan itibaren tüm commit'lerini birleştir.
• fastforward::Bool=false: Eğer fastforward true ise, yalnızca birleştirme bir hızlı ileri (mevcut dal başı birleştirilecek commit'lerin atasıdır) ise birleştir, aksi takdirde birleştirmeyi reddet ve false döndür. Bu, git CLI seçeneği --ff-only ile eşdeğerdir.
• merge_opts::MergeOptions=MergeOptions(): merge_opts, çatışma durumunda birleştirme stratejisi gibi birleştirme için seçenekleri belirtir.
• checkout_opts::CheckoutOptions=CheckoutOptions(): checkout_opts, kontrol adımı için seçenekleri belirtir.

Eşdeğer olarak git merge [--ff-only] [<committish> | <branch>].

merge!(repo::GitRepo, anns::Vector{GitAnnotated}; kwargs...) -> Bool

Açıklamalı commitlerden (GitAnnotated nesneleri olarak yakalanmış) anns değişikliklerini repo deposunun HEAD'ine birleştirir. Anahtar kelime argümanları şunlardır:

• merge_opts::MergeOptions = MergeOptions(): birleştirmenin nasıl yapılacağına dair seçenekler, hızlı ileri almanın izin verilip verilmediği dahil. Daha fazla bilgi için MergeOptions kısmına bakın.
• checkout_opts::CheckoutOptions = CheckoutOptions(): checkout'un nasıl yapılacağına dair seçenekler. Daha fazla bilgi için CheckoutOptions kısmına bakın.

anns uzak veya yerel dal başlarını referans alabilir. Birleştirme başarılıysa true, aksi takdirde false döner (örneğin, dalların ortak bir atası olmadığı için birleştirme mümkün değilse).

Örnekler

upst_ann = LibGit2.GitAnnotated(repo, "branch/a")

# dalı birleştir
LibGit2.merge!(repo, [upst_ann])

merge!(repo::GitRepo, anns::Vector{GitAnnotated}, fastforward::Bool; kwargs...) -> Bool

Açıklamalı commitlerden (GitAnnotated nesneleri olarak yakalanmış) anns değişikliklerini repo deposunun HEAD'ine birleştirir. Eğer fastforward true ise, sadece hızlı birleştirme yapılmasına izin verilir. Bu durumda, eğer çatışmalar meydana gelirse, birleştirme başarısız olacaktır. Aksi takdirde, eğer fastforward false ise, birleştirme, kullanıcının çözmesi gereken bir çatışma dosyası üretebilir.

Anahtar argümanlar şunlardır:

• merge_opts::MergeOptions = MergeOptions(): birleştirmenin nasıl yapılacağına dair seçenekler, hızlı birleştirmenin izin verilip verilmediği dahil. Daha fazla bilgi için MergeOptions kısmına bakın.
• checkout_opts::CheckoutOptions = CheckoutOptions(): checkout'un nasıl yapılacağına dair seçenekler. Daha fazla bilgi için CheckoutOptions kısmına bakın.

anns uzaktan veya yerel dal başlarına atıfta bulunabilir. Birleştirme başarılı olursa true, aksi takdirde false döner (örneğin, dalların ortak bir atası olmadığı için birleştirme mümkün değilse).

Örnekler

upst_ann_1 = LibGit2.GitAnnotated(repo, "branch/a")

# dalı birleştir, hızlı birleştir
LibGit2.merge!(repo, [upst_ann_1], true)

# birleştirme çatışmaları!
upst_ann_2 = LibGit2.GitAnnotated(repo, "branch/b")
# dalı birleştir, hızlı birleştirmeyi dene
LibGit2.merge!(repo, [upst_ann_2], true) # false dönecek
LibGit2.merge!(repo, [upst_ann_2], false) # true dönecek

ffmerge!(repo::GitRepo, ann::GitAnnotated)

Mevcut HEAD'e hızlı birleştirme değişiklikleri. Bu, yalnızca ann tarafından belirtilen commit'in mevcut HEAD'den türetilmesi durumunda mümkündür (örneğin, yerel dal ucundan sadece ileri olan bir uzak daldan değişiklikler çekerken).

LibGit2.fullname(ref::GitReference)

Sembolik referans ref tarafından gösterilen referansın adını döndürür. Eğer ref sembolik bir referans değilse, boş bir dize döndürür.

features()

Mevcut libgit2 sürümünün desteklediği git özelliklerinin bir listesini döndürür, örneğin çoklu iş parçacığı veya HTTPS veya SSH kullanımı gibi.

filename(te::GitTreeEntry)

te'ye atıfta bulunan nesnenin disk üzerindeki dosya adını döndürür.

filemode(te::GitTreeEntry) -> Cint

te'ye atıfta bulunan diskteki nesnenin UNIX dosya modunu bir tamsayı olarak döndürür.

LibGit2.gitdir(repo::GitRepo)

repo'nun "git" dosyalarının konumunu döndürür:

• normal depolar için, bu .git klasörünün konumudur.
• çıplak depolar için, bu deponun kendisinin konumudur.

Ayrıca workdir, path bakınız.

LibGit2.git_url(; kwargs...) -> String

Verilen URL bileşenlerine dayalı bir dize oluşturur. scheme anahtar kelimesi sağlanmadığında üretilen URL, alternatif scp-benzeri sözdizimini kullanacaktır.

Anahtar Kelimeler

• scheme::AbstractString="": kullanılacak protokolü tanımlayan URL şeması. HTTP için "http", SSH için "ssh" vb. scheme sağlanmadığında çıktı formatı "ssh" olacak ancak scp-benzeri sözdizimini kullanacaktır.
• username::AbstractString="": sağlandığında çıktıda kullanılacak kullanıcı adı.
• password::AbstractString="": sağlandığında çıktıda kullanılacak şifre.
• host::AbstractString="": çıktıda kullanılacak ana bilgisayar adı. Bir ana bilgisayar adının belirtilmesi gerekmektedir.
• port::Union{AbstractString,Integer}="": sağlandığında çıktıda kullanılacak port numarası. scp-benzeri sözdizimi kullanıldığında belirtilemez.
• path::AbstractString="": sağlandığında çıktıda kullanılacak yol.

!!! uyarı URL'lerde şifre kullanmaktan kaçının. Kimlik bilgisi nesnelerinin aksine, Julia hassas verileri kullanımdan sonra güvenli bir şekilde sıfırlayamaz veya yok edemez ve şifre bellek içinde kalabilir; bu da belirsiz bir bellek tarafından ifşa edilebilir.

Örnekler

julia> LibGit2.git_url(username="git", host="github.com", path="JuliaLang/julia.git")
"git@github.com:JuliaLang/julia.git"

julia> LibGit2.git_url(scheme="https", host="github.com", path="/JuliaLang/julia.git")
"https://github.com/JuliaLang/julia.git"

julia> LibGit2.git_url(scheme="ssh", username="git", host="github.com", port=2222, path="JuliaLang/julia.git")
"ssh://git@github.com:2222/JuliaLang/julia.git"

@githash_str -> AbstractGitHash

Verilen stringden bir git hash nesnesi oluşturur, eğer string 40 onaltılık basamaktan daha kısa ise bir GitShortHash, aksi takdirde bir GitHash döner.

Örnekler

julia> LibGit2.githash"d114feb74ce633"
GitShortHash("d114feb74ce633")

julia> LibGit2.githash"d114feb74ce63307afe878a5228ad014e0289a85"
GitHash("d114feb74ce63307afe878a5228ad014e0289a85")

LibGit2.head(repo::GitRepo) -> GitReference

repo'nun mevcut HEAD'ine bir GitReference döndürür.

head(pkg::AbstractString) -> String

pkg deposunun mevcut HEAD GitHash değerini bir dize olarak döndürür.

LibGit2.head!(repo::GitRepo, ref::GitReference) -> GitReference

repo'nun HEAD'ini ref tarafından işaret edilen nesneye ayarlayın.

LibGit2.head_oid(repo::GitRepo) -> GitHash

Git deposunun repo mevcut HEAD'inin nesne kimliğini bul.

LibGit2.headname(repo::GitRepo)

Git deposunun repo mevcut HEAD'inin adını bulur. Eğer repo şu anda ayrılmış durumdaysa, ayrıldığı HEAD'in adını döner.

LibGit2.init(path::AbstractString, bare::Bool=false) -> GitRepo

path'te yeni bir git deposu açar. Eğer bare false ise, çalışma ağacı path/.git içinde oluşturulacaktır. Eğer bare true ise, hiçbir çalışma dizini oluşturulmayacaktır.

is_ancestor_of(a::AbstractString, b::AbstractString, repo::GitRepo) -> Bool

a, bir GitHash biçiminde dize olarak, b'nin, bir GitHash biçiminde dize olarak, atası ise true döner.

Örnekler

julia> repo = GitRepo(repo_path);

julia> LibGit2.add!(repo, test_file1);

julia> commit_oid1 = LibGit2.commit(repo, "commit1");

julia> LibGit2.add!(repo, test_file2);

julia> commit_oid2 = LibGit2.commit(repo, "commit2");

julia> LibGit2.is_ancestor_of(string(commit_oid1), string(commit_oid2), repo)
true

isbinary(blob::GitBlob) -> Bool

Bir dosyanın ikili olup olmadığını tahmin etmek için bir sezgi kullanın: NULL baytları aramak ve ilk 8000 bayt arasında yazdırılabilir ile yazdırılamaz karakterlerin makul bir oranını aramak.

iscommit(id::AbstractString, repo::GitRepo) -> Bool

id (string biçiminde bir GitHash) olan commit'in depo içinde olup olmadığını kontrol eder.

Örnekler

julia> repo = GitRepo(repo_path);

julia> LibGit2.add!(repo, test_file);

julia> commit_oid = LibGit2.commit(repo, "add test_file");

julia> LibGit2.iscommit(string(commit_oid), repo)
true

LibGit2.isdiff(repo::GitRepo, treeish::AbstractString, pathspecs::AbstractString=""; cached::Bool=false)

treeish tarafından belirtilen ağaç ile çalışma ağacındaki izlenen dosyalar (eğer cached=false ise) veya indeks (eğer cached=true ise) arasındaki herhangi bir fark olup olmadığını kontrol eder. pathspecs, diff için seçeneklerin spesifikasyonlarıdır.

Örnekler

repo = LibGit2.GitRepo(repo_path)
LibGit2.isdiff(repo, "HEAD") # false olmalı
open(joinpath(repo_path, new_file), "a") do f
    println(f, "işte benim harika yeni dosyam")
end
LibGit2.isdiff(repo, "HEAD") # şimdi true

git diff-index <treeish> [-- <pathspecs>] ile eşdeğerdir.

LibGit2.isdirty(repo::GitRepo, pathspecs::AbstractString=""; cached::Bool=false) -> Bool

Çalışma ağacındaki (eğer cached=false ise) veya dizindeki (eğer cached=true ise) izlenen dosyalarda herhangi bir değişiklik olup olmadığını kontrol eder. pathspecs, fark için seçeneklerin spesifikasyonlarıdır.

Örnekler

repo = LibGit2.GitRepo(repo_path)
LibGit2.isdirty(repo) # false olmalı
open(joinpath(repo_path, new_file), "a") do f
    println(f, "işte benim harika yeni dosyam")
end
LibGit2.isdirty(repo) # şimdi true
LibGit2.isdirty(repo, new_file) # şimdi true

git diff-index HEAD [-- <pathspecs>] ile eşdeğerdir.

LibGit2.isorphan(repo::GitRepo)

Mevcut dalın "yetim" bir dal olup olmadığını kontrol eder, yani hiç commit yoktur. Bu dala yapılacak ilk commit'in ebeveynleri olmayacaktır.

isset(val::Integer, flag::Integer)

val'in flag ile indekslenmiş bitlerinin ayarlı (1) veya ayarsız (0) olup olmadığını test eder.

iszero(id::GitHash) -> Bool

Verilen GitHash değerinin tüm onaltılık basamaklarının sıfır olup olmadığını belirleyin.

lookup_branch(repo::GitRepo, branch_name::AbstractString, remote::Bool=false) -> Union{GitReference, Nothing}

branch_name ile belirtilen dalın repo deposunda mevcut olup olmadığını belirleyin. Eğer remote true ise, repo bir uzak git deposu olarak varsayılır. Aksi takdirde, yerel dosya sisteminin bir parçasıdır.

Mevcutsa istenen dala bir GitReference döndürün, aksi takdirde nothing döndürün.

LibGit2.map(f::Function, walker::GitRevWalker; oid::GitHash=GitHash(), range::AbstractString="", by::Cint=Consts.SORT_NONE, rev::Bool=false)

GitRevWalker walker kullanarak depo tarihindeki her bir commit üzerinde "yürüyün", f'yi yürüyüşteki her bir commit'e uygulayın. Anahtar argümanlar şunlardır: * oid: Yürüyüşe başlamak için commit'in GitHash. Varsayılan olarak, push_head! kullanılır ve dolayısıyla HEAD commit'i ve tüm atalarına başvurulur. * range: GitHash'lerin oid1..oid2 formatındaki bir aralığı. f, ikisi arasındaki tüm commit'lere uygulanacaktır. * by: Sıralama yöntemi. Varsayılan sıralama yoktur. Diğer seçenekler, topolojik sıralama (LibGit2.Consts.SORT_TOPOLOGICAL), zamana göre ileri sıralama (LibGit2.Consts.SORT_TIME, en eski önce) veya zamana göre geri sıralama (LibGit2.Consts.SORT_REVERSE, en yeni önce) şeklindedir. * rev: Sıralı düzeni tersine çevirip çevirmeyeceği (örneğin, topolojik sıralama kullanılıyorsa).

Örnekler

oids = LibGit2.with(LibGit2.GitRevWalker(repo)) do walker
    LibGit2.map((oid, repo)->string(oid), walker, by=LibGit2.Consts.SORT_TIME)
end

Burada, LibGit2.map her bir commit'i GitRevWalker kullanarak ziyaret eder ve GitHash'ini bulur.

Ayna geri çağırma işlevi

Fonksiyon, uzak referans için +refs/*:refs/* referans spesifikasyonlarını ve mirror bayrağını ayarlar.

C işlev işaretçisi mirror_callback için

message(c::GitCommit, raw::Bool=false)

c commitinde yapılan değişiklikleri tanımlayan commit mesajını döndürür. Eğer raw false ise, biraz "temizlenmiş" bir mesaj döndürülür (bu, herhangi bir baştaki yeni satırın kaldırıldığı anlamına gelir). Eğer raw true ise, mesaj bu tür yeni satırlardan arındırılmaz.

merge_analysis(repo::GitRepo, anns::Vector{GitAnnotated}) -> analysis, preference

Açıklama: anns tarafından işaretlenen dallar üzerinde analiz yapın ve hangi koşullar altında birleştirilebileceklerini belirleyin. Örneğin, eğer anns[1] sadece ann[2]'nin bir atasıysa, merge_analysis hızlı bir birleştirme işleminin mümkün olduğunu bildirecektir.

İki çıktı döndürün: analysis ve preference. analysis birkaç olası değere sahiptir:

• MERGE_ANALYSIS_NONE: anns öğelerinin birleştirilmesi mümkün değildir.
• MERGE_ANALYSIS_NORMAL: HEAD ve kullanıcının birleştirmek istediği commit'lerin hepsinin ortak bir atadan ayrıldığı normal bir birleştirme. Bu durumda değişikliklerin çözülmesi gerekir ve çatışmalar meydana gelebilir.
• MERGE_ANALYSIS_UP_TO_DATE: kullanıcının birleştirmek istediği tüm giriş commit'leri HEAD'den ulaşılabilir, bu nedenle birleştirme yapılmasına gerek yoktur.
• MERGE_ANALYSIS_FASTFORWARD: giriş commit'i HEAD'in bir alt kümesidir ve bu nedenle birleştirme yapılmasına gerek yoktur - bunun yerine kullanıcı sadece giriş commit'lerini kontrol edebilir.
• MERGE_ANALYSIS_UNBORN: depo HEAD'i mevcut olmayan bir commit'e işaret ediyor. Birleştirme yapmak mümkün değildir, ancak giriş commit'lerini kontrol etmek mümkün olabilir.

preference de birkaç olası değere sahiptir:

• MERGE_PREFERENCE_NONE: kullanıcının tercihi yoktur.
• MERGE_PREFERENCE_NO_FASTFORWARD: hızlı birleştirme işlemlerine izin vermeyin.
• MERGE_PREFERENCE_FASTFORWARD_ONLY: yalnızca hızlı birleştirme işlemlerine izin verin ve başka bir türüne (çatışmalara neden olabilecek) izin vermeyin. preference, depo veya global git yapılandırması aracılığıyla kontrol edilebilir.

LibGit2.name(ref::GitReference)

ref'in tam adını döndürür.

name(rmt::GitRemote)

Bir uzak depo adını alın, örneğin "origin". Eğer uzak depo anonimse (bkz. GitRemoteAnon) ad boş bir dize "" olacaktır.

Örnekler

julia> repo_url = "https://github.com/JuliaLang/Example.jl";

julia> repo = LibGit2.clone(cache_repo, "test_directory");

julia> remote = LibGit2.GitRemote(repo, "origin", repo_url);

julia> name(remote)
"origin"

LibGit2.name(tag::GitTag)

tag'ın adı (örneğin, "v0.5").

need_update(repo::GitRepo)

git update-index ile eşdeğerdir. repo güncellenmesi gerekiyorsa true döner.

objtype(obj_type::Consts.OBJECT)

Enum değerine karşılık gelen türü döndürür.

LibGit2.path(repo::GitRepo)

Depo repo'nun temel dosya yolunu döndürür.

• normal depolar için, bu genellikle ".git" dizininin üst dizini olacaktır (not: bu, çalışma dizininden farklı olabilir, daha fazla bilgi için workdir'e bakın).
• çıplak depolar için, bu "git" dosyalarının konumudur.

Ayrıca bkz. gitdir, workdir.

peel([T,] ref::GitReference)

ref'i T türünde bir nesne elde edilene kadar özyinelemeli olarak soyulacaktır. Eğer T sağlanmazsa, ref bir GitTag dışındaki bir nesne elde edilene kadar soyulacaktır.

• Bir GitTag, referans verdiği nesneye soyulacaktır.
• Bir GitCommit, bir GitTree nesnesine soyulacaktır.

peel([T,] obj::GitObject)

obj'yi, T türünde bir nesne elde edilene kadar özyinelemeli olarak soyun. Eğer T sağlanmamışsa, obj türü değişene kadar soyulacaktır.

• Bir GitTag, referans verdiği nesneye soyulacaktır.
• Bir GitCommit, bir GitTree'ye soyulacaktır.

LibGit2.posixpath(path)

path dizesini POSIX ayırıcılarını kullanacak şekilde standartlaştırır.

push(rmt::GitRemote, refspecs; force::Bool=false, options::PushOptions=PushOptions())

Belirtilen rmt uzak git deposuna refspecs kullanarak hangi uzak dal(lar)a itileceğini belirleyerek itme yapar. Anahtar argümanlar şunlardır:

• force: true ise, çatışmaları göz ardı ederek zorla itme yapılır.
• options: itme için seçenekleri belirler, örneğin hangi proxy başlıklarının kullanılacağını. Daha fazla bilgi için PushOptions kısmına bakın.

push(repo::GitRepo; kwargs...)

repo'nun bir üst akışına güncellemeleri gönderir.

Anahtar kelime argümanları şunlardır:

• remote::AbstractString="origin": gönderilecek üst akış uzaktan adıdır.
• remoteurl::AbstractString="": remote'un URL'sidir.
• refspecs=AbstractString[]: gönderimin özelliklerini belirler.
• force::Bool=false: gönderimin zorla gönderim olup olmayacağını belirler, uzaktan dalı üzerine yazar.
• credentials=nothing: özel bir remote ile kimlik doğrularken kimlik bilgileri ve/veya ayarlar sağlar.
• callbacks=Callbacks(): kullanıcı tarafından sağlanan geri çağırmalar ve yükler.

git push [<remoteurl>|<repo>] [<refspecs>] ile eşdeğerdir.

LibGit2.push!(w::GitRevWalker, cid::GitHash)

GitRevWalker walker'ı cid commit'inde başlatın. Bu fonksiyon, belirli bir yıl itibarıyla tüm commit'lere bir fonksiyon uygulamak için kullanılabilir; bu, o yılın ilk commit'ini cid olarak geçirip ardından elde edilen w'yi LibGit2.map fonksiyonuna geçirerek yapılır.

LibGit2.push_head!(w::GitRevWalker)

HEAD commitini ve onun atalarını GitRevWalker w üzerine it. Bu, HEAD'in ve tüm atalarının yürüyüş sırasında karşılaşılmasını sağlar.

push_refspecs(rmt::GitRemote) -> Vector{String}

Belirtilen rmt için push refspec'lerini alır. Bu refspec'ler hangi dal(lar)ın itileceği hakkında bilgi içerir.

Örnekler

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.add_push!(repo, remote, "refs/heads/master");

julia> close(remote);

julia> remote = LibGit2.get(LibGit2.GitRemote, repo, "upstream");

julia> LibGit2.push_refspecs(remote)
String["refs/heads/master"]

raw(id::GitHash) -> Vector{UInt8}

GitHash olarak 20 uzunluğunda bir vektör olarak ham baytları elde edin.

LibGit2.read_tree!(idx::GitIndex, tree::GitTree)
LibGit2.read_tree!(idx::GitIndex, treehash::AbstractGitHash)

Ağaç tree'i (veya idx tarafından sahip olunan depodaki treehash ile işaretlenen ağacı) idx dizinine oku. Mevcut dizin içeriği değiştirilecektir.

LibGit2.rebase!(repo::GitRepo, upstream::AbstractString="", newbase::AbstractString="")

Mevcut dalın otomatik bir birleştirme rebase'ini upstream sağlanmışsa ondan, aksi takdirde yukarı akış izleme dalından denemektedir. newbase, üzerine rebase yapılacak dalı belirtir. Varsayılan olarak bu upstream'dir.

Eğer otomatik olarak çözülemeyen herhangi bir çelişki ortaya çıkarsa, rebase iptal edilecek ve depo ile çalışma ağacı orijinal durumunda kalacak ve fonksiyon bir GitError fırlatacaktır. Bu, aşağıdaki komut satırı ifadesine yaklaşık olarak eşdeğerdir:

git rebase --merge [<upstream>]
if [ -d ".git/rebase-merge" ]; then
    git rebase --abort
fi

LibGit2.ref_list(repo::GitRepo) -> Vector{String}

repo deposunda tüm referans adlarının bir listesini alır.

LibGit2.reftype(ref::GitReference) -> Cint

ref'in türüne karşılık gelen bir Cint döndür:

• Referans geçersizse 0
• Referans bir nesne kimliği ise 1
• Referans sembolikse 2

LibGit2.remotes(repo::GitRepo)

repo'nun uzaktan bağlantılarının adlarının bir vektörünü döndürür.

remove!(repo::GitRepo, files::AbstractString...)
remove!(idx::GitIndex, files::AbstractString...)

idx (veya repo'nun indeksi) içinde files ile belirtilen yollarla tüm dosyaları kaldırın.

reset(val::Integer, flag::Integer)

val'in flag ile indekslenmiş bitlerini sıfırlayarak, onları 0'a döndürür.

reset!(payload, [config]) -> CredentialPayload

payload durumunu başlangıç değerlerine geri sıfırlar, böylece kimlik bilgisi geri çağrısı içinde tekrar kullanılabilir. Eğer bir config sağlanmışsa, yapılandırma da güncellenecektir.

Hedef commit ağacından pathspecs ile belirlenen bazı girişleri dizinde günceller.

Geçerli başı belirtilen commit oid'sine ayarlar ve isteğe bağlı olarak dizini ve çalışma ağacını eşleştirecek şekilde sıfırlar.

git reset [<committish>] [–] <pathspecs>...

reset!(repo::GitRepo, id::GitHash, mode::Cint=Consts.RESET_MIXED)

Depoyu repo'yu id'deki durumuna, mode ile belirlenen üç moddan birini kullanarak sıfırlayın:

1. Consts.RESET_SOFT - HEAD'i id'ye taşıyın.
2. Consts.RESET_MIXED - varsayılan, HEAD'i id'ye taşıyın ve dizini id'ye sıfırlayın.
3. Consts.RESET_HARD - HEAD'i id'ye taşıyın, dizini id'ye sıfırlayın ve tüm çalışma değişikliklerini atın.

Örnekler

# değişiklikleri al
LibGit2.fetch(repo)
isfile(joinpath(repo_path, our_file)) # false dönecek

# değişiklikleri hızlı birleştir
LibGit2.merge!(repo, fastforward=true)

# çünkü yerel olarak herhangi bir dosya yoktu, ama
# uzakta bir dosya var, bu yüzden dalı sıfırlamamız gerekiyor
head_oid = LibGit2.head_oid(repo)
new_head = LibGit2.reset!(repo, head_oid, LibGit2.Consts.RESET_HARD)

Bu örnekte, alınan uzaktan bir dosya our_file adında bir dosya var, bu yüzden sıfırlamamız gerekiyor.

git reset [--soft | --mixed | --hard] <id> ile eşdeğerdir.

Örnekler

repo = LibGit2.GitRepo(repo_path)
head_oid = LibGit2.head_oid(repo)
open(joinpath(repo_path, "file1"), "w") do f
    write(f, "111
")
end
LibGit2.add!(repo, "file1")
mode = LibGit2.Consts.RESET_HARD
# file1'deki değişiklikleri atacak
# ve onu sahneden çıkaracak
new_head = LibGit2.reset!(repo, head_oid, mode)

restore(s::State, repo::GitRepo)

Bir repo deposunu, birleştirme denemesi öncesindeki bir dalın HEAD'i gibi, önceki bir State s'ye geri döndürür. s, snapshot fonksiyonu kullanılarak oluşturulabilir.

LibGit2.revcount(repo::GitRepo, commit1::AbstractString, commit2::AbstractString)

commit1 ve commit2 arasındaki revizyon sayısını listeleyin (komit OID'leri string biçiminde). commit1 ve commit2 farklı dallarda olabileceğinden, revcount "sol-sağ" revizyon listesi (ve sayımı) gerçekleştirir ve bir Int tuple'ı döndürür - sırasıyla sol ve sağ komitlerin sayısı. Sol (veya sağ) bir komit, bir ağaçtaki simetrik farkın hangi tarafında komitin erişilebilir olduğunu ifade eder.

Eşdeğer olarak git rev-list --left-right --count <commit1> <commit2>.

Örnekler

repo = LibGit2.GitRepo(repo_path)
repo_file = open(joinpath(repo_path, test_file), "a")
println(repo_file, "hello world")
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid1 = LibGit2.commit(repo, "commit 1")
println(repo_file, "hello world again")
flush(repo_file)
LibGit2.add!(repo, test_file)
commit_oid2 = LibGit2.commit(repo, "commit 2")
LibGit2.revcount(repo, string(commit_oid1), string(commit_oid2))

Bu (-1, 0) döndürecektir.

set_remote_url(repo::GitRepo, remote_name, url)
set_remote_url(repo::String, remote_name, url)

remote_name için hem fetch hem de push url'sini GitRepo veya path'te bulunan git deposu için ayarlayın. Genellikle git reposu "origin"'i uzak ad olarak kullanır.

Örnekler

repo_path = joinpath(tempdir(), "Example")
repo = LibGit2.init(repo_path)
LibGit2.set_remote_url(repo, "upstream", "https://github.com/JuliaLang/Example.jl")
LibGit2.set_remote_url(repo_path, "upstream2", "https://github.com/JuliaLang/Example2.jl")

LibGit2.shortname(ref::GitReference)

ref'in kısaltılmış, "insan tarafından okunabilir" bir versiyonunu döndürür.

julia> repo = GitRepo(path_to_repo);

julia> branch_ref = LibGit2.head(repo);

julia> LibGit2.name(branch_ref)
"refs/heads/master"

julia> LibGit2.shortname(branch_ref)
"master"

snapshot(repo::GitRepo) -> State

Mevcut repo deposunun durumunun bir anlık görüntüsünü alır, mevcut HEAD'i, dizini ve herhangi bir taahhüt edilmemiş çalışmayı saklar. Çıktı State, daha sonra restore çağrısında kullanılarak deponun anlık görüntülenen duruma geri döndürülmesi için kullanılabilir.

LibGit2.split_cfg_entry(ce::LibGit2.ConfigEntry) -> Tuple{String,String,String,String}

ConfigEntry'yi aşağıdaki parçalara ayırır: bölüm, alt bölüm, ad ve değer.

Örnekler

Aşağıdaki git yapılandırma dosyasını göz önünde bulundurun:

[credential "https://example.com"]
    username = me

ConfigEntry aşağıdaki gibi görünecektir:

julia> entry
ConfigEntry("credential.https://example.com.username", "me")

julia> LibGit2.split_cfg_entry(entry)
("credential", "https://example.com", "username", "me")

Daha fazla bilgi için git config sözdizimi belgelerine bakın.

LibGit2.status(repo::GitRepo, path::String) -> Union{Cuint, Cvoid}

repo içindeki path'teki dosyanın durumunu kontrol edin. Örneğin, bu, path'teki dosyanın değiştirilip değiştirilmediğini ve sahneye alınması ve taahhüt edilmesi gerekip gerekmediğini kontrol etmek için kullanılabilir.

stage(ie::IndexEntry) -> Cint

ie'nin aşama numarasını alır. Aşama numarası 0, çalışma ağacının mevcut durumunu temsil eder, ancak diğer numaralar birleştirme çatışması durumunda kullanılabilir. Bu durumda, bir IndexEntry üzerindeki çeşitli aşama numaraları, dosyanın mevcut durumunun hangi taraf(lar)ına ait olduğunu tanımlar. Aşama 0, denenen birleştirmeden önceki durumu, aşama 1 ise yerel olarak yapılan değişiklikleri temsil eder, aşama 2 ve daha büyükleri ise diğer dallardan gelen değişiklikler içindir (örneğin, çoklu dal "oktopus" birleştirmesi durumunda, aşama 2, 3 ve 4 kullanılabilir).

LibGit2.tag_create(repo::GitRepo, tag::AbstractString, commit; kwargs...)

Yeni bir git etiketi tag (örneğin, "v0.5") oluşturur, repo deposunda, commit üzerinde.

Anahtar kelime argümanları şunlardır:

• msg::AbstractString="": etiket için mesaj.
• force::Bool=false: true ise, mevcut referanslar üzerine yazılacaktır.
• sig::Signature=Signature(repo): etiketleyicinin imzası.

LibGit2.tag_delete(repo::GitRepo, tag::AbstractString)

Depoyu repo'dan tag git etiketini kaldırır.

LibGit2.tag_list(repo::GitRepo) -> Vector{String}

Git deposu repo içindeki tüm etiketlerin bir listesini alır.

LibGit2.target(tag::GitTag)

tag'in hedef nesnesinin GitHash'i.

toggle(val::Integer, flag::Integer)

val'in flag ile indekslenmiş bitlerini çevirin, böylece bir bit 0 ise toggle'dan sonra 1 olacak ve tersine.

transact(f::Function, repo::GitRepo)

Git deposu repo üzerinde f fonksiyonunu uygulayın, f uygulamadan önce bir snapshot alarak. Eğer f içinde bir hata oluşursa, repo snapshot durumuna geri dönecektir restore kullanılarak. Oluşan hata yeniden fırlatılacak, ancak repo durumu bozulmayacaktır.

treewalk(f, tree::GitTree, post::Bool=false)

tree içindeki ve alt ağaçlarındaki girişleri post veya pre sırasına göre gezmek için kullanılır. Preorder, kökten başlayarak en soldaki alt ağaca geçmek (ve o alt ağacın en soldaki alt ağaçları boyunca özyinelemeli olarak devam etmek) ve alt ağaçlar boyunca sağa doğru hareket etmek anlamına gelir. Postorder ise en soldaki alt ağacın en altından başlayarak yukarı doğru geçmek, ardından bir sonraki sağ alt ağacı (yine en alttan başlayarak) gezmek ve en son olarak ağaç kökünü ziyaret etmek anlamına gelir.

Fonksiyon parametresi f aşağıdaki imzaya sahip olmalıdır:

(String, GitTreeEntry) -> Cint

f'den dönen negatif bir değer ağaç yürüyüşünü durdurur. Pozitif bir değer, post false ise girişin atlanacağı anlamına gelir.

upstream(ref::GitReference) -> Union{GitReference, Nothing}

ref içeren dalın belirli bir yukarı akış dalı olup olmadığını belirleyin.

Eğer varsa yukarı akış dalına bir GitReference döndürün, aksi takdirde istenen dalın yukarı akış karşılığı yoksa nothing döndürün.

update!(repo::GitRepo, files::AbstractString...)
update!(idx::GitIndex, files::AbstractString...)

files ile belirtilen yollarla tüm dosyaları idx (veya repo'nun indeksinde) güncelleyin. Her dosyanın indeksindeki durumunu disk üzerindeki mevcut durumla eşleştirin, diskten kaldırılmışsa onu kaldırın veya nesne veritabanındaki girişini güncelleyin.

url(rmt::GitRemote)

Uzak bir git deposunun fetch URL'sini al.

Örnekler

julia> repo_url = "https://github.com/JuliaLang/Example.jl";

julia> repo = LibGit2.init(mktempdir());

julia> remote = LibGit2.GitRemote(repo, "origin", repo_url);

julia> LibGit2.url(remote)
"https://github.com/JuliaLang/Example.jl"

version() -> VersionNumber

Kullanımda olan libgit2 sürümünü, bir VersionNumber olarak döndürür.

with(f::Function, obj)

Kaynak yönetimi yardımcı fonksiyonu. f'yi obj'ye uygular, f başarılı bir şekilde döndüğünde veya bir hata fırlattığında obj üzerinde close çağrısı yapmayı garanti eder. Tahsis edilen git kaynaklarının, artık ihtiyaç duyulmadığında en kısa sürede sonlandırılmasını sağlar.

with_warn(f::Function, ::Type{T}, args...)

Kaynak yönetimi yardımcı işlevi. args'dan T türünde bir örnek oluşturarak f'yi args'ya uygular. f başarılı bir şekilde döndüğünde veya bir hata fırlattığında, elde edilen nesne üzerinde close çağrısı yapıldığından emin olur. Tahsis edilen git kaynaklarının, artık ihtiyaç duyulmadıklarında mümkün olan en kısa sürede sonlandırılmasını sağlar. f tarafından bir hata fırlatıldığında, hatayı içeren bir uyarı gösterilir.

LibGit2.workdir(repo::GitRepo)

repo'nun çalışma dizininin konumunu döndürür. Bu, çıplak depolar için bir hata verecektir.

Ayrıca bkz. gitdir, path.

(::Type{T})(te::GitTreeEntry) where T<:GitObject

te'ye atıfta bulunan git nesnesini al ve onu gerçek türü olarak döndür (örneğin entrytype türü gösterir), örneğin bir GitBlob veya GitTag.

Örnekler

tree = LibGit2.GitTree(repo, "HEAD^{tree}")
tree_entry = tree[1]
blob = LibGit2.GitBlob(tree_entry)

Sadece user ve password parametrelerini destekleyen kimlik bilgileri

SSH kimlik türü

isfilled(cred::AbstractCredential) -> Bool

Bir kimliğin kimlik doğrulama için kullanılmaya hazır olduğunu doğrular.

Kimlik bilgilerini yeniden kullanmak için önbelleğe alır.

LibGit2.CredentialPayload

Aynı URL için kimlik bilgisi geri çağrısına yapılan birden fazla çağrı arasında durumu korur. Farklı bir URL ile kullanılmadan önce bir CredentialPayload örneğinin reset! ile sıfırlanması beklenir.

approve(payload::CredentialPayload; shred::Bool=true) -> Nothing

Gelecek bir kimlik doğrulama işleminde yeniden kullanılmak üzere payload kimlik bilgilerini saklayın. Sadece kimlik doğrulama başarılı olduğunda çağrılmalıdır.

shred anahtarı, yük kimlik bilgisi alanındaki hassas bilgilerin yok edilip edilmeyeceğini kontrol eder. Sadece test sırasında false olarak ayarlanmalıdır.

reject(payload::CredentialPayload; shred::Bool=true) -> Nothing

Gelecek kimlik doğrulamalarında yeniden kullanılmak üzere payload kimlik bilgisi reddedilir. Sadece kimlik doğrulama başarısız olduğunda çağrılmalıdır.

shred anahtarı, yük kimlik bilgisi alanındaki hassas bilgilerin yok edilip edilmeyeceğini kontrol eder. Sadece test sırasında false olarak ayarlanmalıdır.

Bir yapılandırma dosyasının öncelik seviyesi.

Bu öncelik seviyeleri, git'te yapılandırma girişlerini ararken doğal yükselme mantığına (yüksekten düşüğe) karşılık gelir.

• CONFIG_LEVEL_DEFAULT - Mevcutsa, global, XDG ve sistem yapılandırma dosyalarını açın.
• CONFIG_LEVEL_PROGRAMDATA - Taşınabilir git ile uyumluluk için Windows'ta sistem genelinde
• CONFIG_LEVEL_SYSTEM - Sistem genelinde yapılandırma dosyası; Linux sistemlerinde /etc/gitconfig
• CONFIG_LEVEL_XDG - XDG uyumlu yapılandırma dosyası; genellikle ~/.config/git/config
• CONFIG_LEVEL_GLOBAL - Kullanıcıya özel yapılandırma dosyası (aynı zamanda Global yapılandırma dosyası olarak da adlandırılır); genellikle ~/.gitconfig
• CONFIG_LEVEL_LOCAL - Depoya özel yapılandırma dosyası; bare olmayan reposlarda $WORK_DIR/.git/config
• CONFIG_LEVEL_APP - Uygulamaya özel yapılandırma dosyası; uygulamalar tarafından serbestçe tanımlanır
• CONFIG_HIGHEST_LEVEL - Mevcut en yüksek seviye yapılandırma dosyasını temsil eder (yani, gerçekten yüklenen en spesifik yapılandırma dosyası)