İçeriğe geç

PHP API

Markdown olarak görüntüle GitHub üzerinde düzenle Dokümantasyon: bfe242f

Pitmaster\Pitmaster

Pitmaster\Pitmaster sınıfı statik giriş noktasıdır. Depoları açmak, oluşturmak ve klonlamak için fabrika yöntemlerinin yanı sıra algılama yardımcıları sunar.

PHP
use Pitmaster\Pitmaster;

open

PHP
public static function open(string $path, array $options = []): Repository

Mevcut bir depoyu $path konumunda açın. Yol, çalışma ağacının kökü olmalıdır (.git/ içeren). Bağlı çalışma ağaçlarını (.git, gitdir: <path> içeren bir dosyadır) ve yalın depoları ($path, .git dizininin kendisidir) da destekler.

$options, her ikisi de varsayılan olarak true olan iki boole değeri kabul eder:

  • hooks: .git/hooks betiklerini çalıştırır. Bu tanıtıcı için bunları atlamak üzere false değerini geçin.
  • processes: süreç başlatan veya ağ aktarımı açan her şeye izin verir. Hook'ları, fsmonitor hook'unu, clone, fetch, push ve SSH süreç aktarımını devre dışı bırakmak için false değerini geçin. Yerel okuma ve yazma işlemleri çalışmaya devam eder.

Yol bir git deposu değilse InvalidArgumentException fırlatır.

PHP
$repo = Pitmaster::open('/home/user/project');
$repo = Pitmaster::open('/home/user/project', ['hooks' => false]);
$repo = Pitmaster::open('/home/user/project', Pitmaster::processFreeOptions());

init

PHP
public static function init(string $path, string $objectFormat = 'sha1', array $options = []): Repository

$path konumunda yeni bir depo başlatın. .git dizin yapısını objects/, refs/heads/, refs/tags/, hooks/, info/, HEAD (refs/heads/main konumunu gösteren) ve varsayılan bir config ile oluşturur.

$objectFormat, 'sha1' veya 'sha256' olabilir. SHA-256 deposu, yapılandırmasında repositoryformatversion = 1 ve extensions.objectformat = sha256 değerlerini alır. Başka herhangi bir değer InvalidArgumentException fırlatır. $options, open() ile aynı anahtarları alır.

Belirtilen yolda zaten bir depo varsa RuntimeException fırlatır.

PHP
$repo = Pitmaster::init('/home/user/new-project');
$repo = Pitmaster::init('/home/user/sha256-project', 'sha256');

clone

PHP
public static function clone(string $url, string $path, ?int $depth = null, array $options = []): Repository

Uzak bir depoyu klonlayın. Yeni bir depo başlatır, uzak ref'leri keşfeder, pack dosyasını getirir, uzak izleme dallarını ayarlar ve çalışma ağacını oluşturur. SSH URL'leri (ssh://... veya user@host:path) SSH aktarımını kullanır; diğer URL'ler smart HTTP kullanır ve smart alışveriş başarısız olduğunda dumb HTTP yöntemine geri döner. Sığ klon için $depth geçin.

$options['processes'], false ise RuntimeException fırlatır. Klonlama başarısız olursa ve $path önceden mevcut değilse, kısmen oluşturulan dizin kaldırılır.

PHP
$repo = Pitmaster::clone('https://github.com/user/repo.git', '/tmp/repo');
$repo = Pitmaster::clone('https://github.com/user/repo.git', '/tmp/shallow', 1);
$repo = Pitmaster::clone('https://github.com/user/repo.git', '/tmp/repo', null, ['hooks' => false]);

processFreeOptions

PHP
public static function processFreeOptions(): array

Ana makine süreçlerini başlatmaması gereken çalışma ortamları için ['processes' => false, 'hooks' => false] döndürür. Bunu open() veya init()'ye geçin.

isRepository

PHP
public static function isRepository(string $path): bool

Bir yolun git deposu olup olmadığını denetler. Normal depolar (.git/ dizini), bağlı çalışma ağaçları (.git dosyası) ve yalın depolar (HEAD dosyası mevcut) için true döndürür.

PHP
if (Pitmaster::isRepository('/path/to/check')) {
    // It's a git repo
}

isWorktree

PHP
public static function isWorktree(string $path): bool

Bir yolun bağlı çalışma ağacı (ana depo değil) olup olmadığını denetler. Yalnızca .git, gitdir: referansı içeren bir dosyaysa true döndürür.

PHP
if (Pitmaster::isWorktree('/path/to/worktree')) {
    // It's a linked worktree
}

commonGitDir

PHP
public static function commonGitDir(string $path): ?string

Ortak git dizinini herhangi bir checkout yolundan çözümler. Normal depolarda bu, .git dizinidir. Bağlı çalışma ağaçlarında ise nesneleri, yapılandırmayı ve packed-refs'i içeren paylaşılan git dizinidir. Yol bir depo değilse null döndürür.

PHP
$common = Pitmaster::commonGitDir('/path/to/worktree');
// '/path/to/main-repo/.git'

Pitmaster\Repository

Pitmaster\Repository sınıfı, tüm git işlemleri için ana tanıtıcıdır. Pitmaster::open(), Pitmaster::init() veya Pitmaster::clone() aracılığıyla edinin.

PHP
use Pitmaster\Repository;

Yol erişimcileri

gitDir

PHP
public function gitDir(): string

Çalışma ağacına özel git dizinini döndürür. Normal depolarda bu, .git/ konumudur. Bağlı çalışma ağaçlarında ise .git/worktrees/<name>/ konumudur.

commonGitDir

PHP
public function commonGitDir(): string

Paylaşılan git dizinini döndürür. Normal depolarda gitDir() ile aynıdır. Bağlı çalışma ağaçlarında, ana deponun nesneleri, yapılandırmayı ve packed-refs'i içeren .git/ dizinidir.

workDir

PHP
public function workDir(): string

Çalışma ağacının kök yolunu döndürür.

isLinkedWorktree

PHP
public function isLinkedWorktree(): bool

Bu depo tanıtıcısı bağlı bir çalışma ağacıysa true döndürür.

isBare, hooksEnabled, processesEnabled

PHP
public function isBare(): bool
public function hooksEnabled(): bool
public function processesEnabled(): bool

Deponun çalışma ağacı olmadığını ve bu tanıtıcı için hooks / processes seçeneklerinden hangilerinin etkin olduğunu bildirir. Süreçler devre dışı olduğunda hooksEnabled() daima false olur.

Nesneler

readObject

PHP
public function readObject(string $hash): GitObject

Herhangi bir nesneyi tam onaltılık karmasıyla (40 karakter veya SHA-256 deposunda 64 karakter) okuyun. Kısaltılmış karmalar kabul edilmez. Bir Blob, Tree, Commit veya Tag örneği döndürür. Önce gevşek nesneleri, ardından pack dosyalarını arar.

Karma bulunamazsa ObjectNotFoundException fırlatır.

PHP
$object = $repo->readObject('a1b2c3d4e5f6...');

writeObject

PHP
public function writeObject(GitObject $object): ObjectId

Gevşek nesne deposuna bir nesne yazın. Hesaplanan ObjectId değerini döndürür.

PHP
use Pitmaster\Object\Blob;

$blob = Blob::fromContent('Hello, world!');
$id = $repo->writeObject($blob);

catFile

PHP
public function catFile(string $hash): string

Bir nesnenin ham içeriğini döndürür; git cat-file -p ile eşdeğerdir.

PHP
echo $repo->catFile('a1b2c3d4...');

objectExists

PHP
public function objectExists(string $hash): bool

Depoda (gevşek veya paketlenmiş) bir nesnenin bulunup bulunmadığını denetler.

listObjects

PHP
public function listObjects(): array

Depodaki tüm nesne karmalarını listeleyin. Onaltılık dizelerden oluşan bir dizi döndürür.

Ref'ler

PHP
public function head(): Commit

Geçerli HEAD commit'ini döndürür. Sembolik ref'leri izler (HEAD -> refs/heads/main -> commit karması).

HEAD geçerli bir commit'i göstermiyorsa RuntimeException fırlatır (e.g., boş depo).

branch

PHP
public function branch(?string $name = null): ?string

Bağımsız değişken olmadan geçerli dal adını (e.g., 'main') veya HEAD ayrılmışsa null döndürür.

Dal adı verildiğinde, onu commit karmasına (onaltılık dize) çözümler veya dal mevcut değilse null döndürür.

PHP
$current = $repo->branch();        // 'main'
$hash = $repo->branch('feature');   // 'abc123...' or null

branches

PHP
public function branches(): array

Tüm dal adlarının sıralanmış bir dizisini (refs/heads/ öneki olmadan) döndürür.

PHP
$branches = $repo->branches();
// ['bugfix/typo', 'feature/login', 'main']

tags

PHP
public function tags(): array

Tüm etiket adlarının sıralanmış bir dizisini (refs/tags/ öneki olmadan) döndürür.

resolve

PHP
public function resolve(string $revision): ObjectId

Bir revizyon ifadesini ObjectId olarak çözümler. Şunları destekler:

  • Tam onaltılık karmalar (40 karakter veya SHA-256 için 64 karakter). abc1234 gibi kısaltılmış karmalar çözümlenmez.
  • HEAD
  • Dal adları (main, feature/login)
  • Etiket adları (v1.0.0)
  • Tam ref yolları (refs/heads/main)
  • Revizyon ifadeleri (HEAD~3, main^2)

Revizyon çözümlenemiyorsa RuntimeException fırlatır.

PHP
$id = $repo->resolve('HEAD~3');
$id = $repo->resolve('v1.0.0');
$id = $repo->resolve('feature/login');

allRefs

PHP
public function allRefs(): array

Tüm ref'leri, ref adlarından onaltılık karmalara eşleyen ilişkisel dizi olarak döndürür.

PHP
$refs = $repo->allRefs();
// ['refs/heads/main' => 'abc123...', 'refs/tags/v1.0.0' => 'def456...']

updateRef

PHP
public function updateRef(string $name, ObjectId $target): void

Bir ref'i yeni bir hedefi gösterecek şekilde günceller.

PHP
$repo->updateRef('refs/heads/main', $commitId);

createBranch

PHP
public function createBranch(string $name, ?ObjectId $from = null): void

Yeni bir dal oluşturur. $from null ise geçerli HEAD'den dallanır.

PHP
$repo->createBranch('feature/new-thing');
$repo->createBranch('hotfix', $repo->resolve('v1.0.0'));

deleteBranch

PHP
public function deleteBranch(string $name): void

Bir dalı adıyla siler. Dal checkout edilmişse veya mevcut değilse RuntimeException fırlatır. git branch -d'den farklı olarak dalın birleştirilip birleştirilmediğini denetlemez.

PHP
$repo->deleteBranch('feature/old');

createLightweightTag

PHP
public function createLightweightTag(string $name, ?ObjectId $target = null): void

Hafif bir etiket oluşturur. $target null ise geçerli HEAD'i doğrudan etiketler.

PHP
$repo->createLightweightTag('v2.0.0');
$repo->createLightweightTag('hotfix-start', $repo->resolve('main~2'));

createTag

PHP
public function createTag(string $name, string $message, ?ObjectId $target = null, ?string $tagger = null): ObjectId

Açıklamalı bir etiket oluşturur. $target null ise geçerli HEAD'i etiketler. Etiket nesnesinin ObjectId değerini döndürür.

PHP
$tagId = $repo->createTag('v2.0.0', 'Release version 2.0.0');

deleteTag

PHP
public function deleteTag(string $name): void

Bir etiketi adına göre siler.

PHP
$repo->deleteTag('v1.0.0');

packRefs

PHP
public function packRefs(): void

Paylaşılan packed-refs dosyasını geçerli gevşek ref kümesinden yeniden yazar ve karşılık gelen paylaşılan gevşek ref'leri budar. Bağlı çalışma ağaçlarında ortak git dizinine yazar.

PHP
$repo->packRefs();

defaultBranch

PHP
public function defaultBranch(): string

Deponun varsayılan dalını çözümler. Önce uzak HEAD symref'ini, ardından yerel HEAD'i denetler ve son olarak main veya master değerine geri döner.

isBranchMerged

PHP
public function isBranchMerged(string $branch, ?string $target = null): bool

Bir dalın başka bir dala (varsayılan olarak varsayılan dala) tamamen birleştirilip birleştirilmediğini denetler.

PHP
if ($repo->isBranchMerged('feature/done')) {
    $repo->deleteBranch('feature/done');
}

checkout

PHP
public function checkout(string $target): void

Dalları değiştirir veya HEAD'i ayırır. HEAD'i, indeksi ve çalışma ağacını günceller. $target bir dal adı, etiket, tam karma veya revizyon ifadesidir; dal olmayan her şey HEAD'i ayırır.

Geçerli ağaç ile hedef ağaç arasında farklılık gösteren bir yolda yerel değişiklik (hazırlanmış olsun ya da olmasın) veya izlenmeyen dosya varsa RuntimeException fırlatır.

İzlenen diğer dosyalardaki commit edilmemiş değişiklikler taşınmaz: indeks ve çalışma ağacı hedef ağaçtan yeniden oluşturulur; bu nedenle her iki tarafta da aynı olan dosyalardaki düzenlemeler kaybolur; git ise bunları korurdu (#2). Önce commit edin veya stash'e alın. merge(), cherryPick(), revert(), rebase() ve bisect yöntemleri çalışma ağacını aynı şekilde yeniden oluşturur.

PHP
$repo->checkout('feature/login');
$repo->checkout($repo->resolve('v1.0.0')->hex);  // Detached HEAD

İndeks

index

PHP
public function index(): Index

Geçerli indeksi (hazırlama alanı) .git/index konumundan okur ve döndürür.

add

PHP
public function add(string ...$paths): void

Dosyaları hazırlayın. Her dosyayı çalışma ağacından okur, bir blob nesnesi oluşturur ve indeksi günceller. Her bağımsız değişken, çalışma ağacının köküne göreli bir dosya (veya sembolik bağlantı) yolu olmalıdır; dizinler ve glob kalıpları genişletilmez ve dosya yoksa RuntimeException fırlatır.

PHP
$repo->add('src/Feature.php', 'tests/FeatureTest.php');

remove

PHP
public function remove(string ...$paths): void
public function removeCached(string ...$paths): void

İzlenen yolları hem indeksten hem de çalışma ağacından kaldırır. --cached ve Git davranışını taklit eden bağımsız değişken listesindeki -r / --recursive öğelerini destekler.

PHP
$repo->remove('old-file.txt');
$repo->remove('-r', 'src');
$repo->remove('--cached', 'old-file.txt');
$repo->removeCached('old-file.txt');

mv

PHP
public function mv(string $source, string $destination): void

Bir dosyayı hem çalışma ağacında hem de indekste taşır/yeniden adlandırır.

PHP
$repo->mv('old-name.php', 'new-name.php');

Commit'ler

commit

PHP
public function commit(?string $message = null, ?string $author = null): ObjectId

Geçerli indeksten bir commit oluşturur. İndeks girdilerinden bir ağaç hiyerarşisi kurar, varsa üst öğe olarak HEAD'i kullanarak commit nesnesini oluşturur ve HEAD'i günceller. Yeni commit'in ObjectId değerini döndürür.

$message yalnızca birleştirme, cherry-pick, revert veya rebase bir çakışmada durduğunda null olabilir; bu durumda hazırlanan mesaj kullanılır. Aksi durumda null mesajı RuntimeException('Commit message required') fırlatır. İndekste birleştirilmemiş yollar varsa, commit içermeyen bir depoda indeks boşsa veya ağaç HEAD'den değişmemişse de commit işlemi hata verir.

$author parametresi tam bir git yazar dizesidir (Name <email> timestamp timezone). null ise ortam değişkenlerinden, sabitlerden ve .git/config'ten, Başlarken bölümünde açıklanan sırayla çözümlenir.

PHP
$id = $repo->commit('Fix null pointer bug');

show

PHP
public function show(string $revision): array

Bir commit benzeri nesneyi ve ilk üst öğesine göre farkını gösterir. Revizyon açıklamalı bir etikete çözümlendiğinde, döndürülen değer ayrıca ['tag' => Tag] içerir ve commit soyulmuş hedef commit olur.

PHP
$result = $repo->show('HEAD');
echo $result['commit']->message;

foreach ($result['diff'] as $diff) {
    echo $diff->format();
}

reset

PHP
public function reset(string $revision, string $mode = 'mixed'): void

HEAD'i bir commit'e sıfırlar. Modlar:

  • 'soft': yalnızca HEAD'i taşır
  • 'mixed': HEAD'i taşır + indeksi sıfırlar (varsayılan)
  • 'hard': HEAD'i taşır + indeksi sıfırlar + çalışma ağacını sıfırlar
PHP
$repo->reset('HEAD~1', 'soft');
$repo->reset('main', 'hard');

restore

PHP
public function restore(string $path, ?string $source = null, bool $staged = false, bool $worktree = false): void

Bir yolu indeksten veya belirli bir kaynak revizyondan geri yükler. Her iki bayrak da ayarlanmamışsa Pitmaster çalışma ağacını indeksten (verilmişse $source konumundan) geri yükler. staged: true, indeksi HEAD'den (veya $source konumundan) geri yükler ve çalışma ağacına dokunmaz; ikisini birden geri yüklemek için staged: true, worktree: true geçin.

PHP
$repo->restore('src/File.php');                                        // Worktree from index
$repo->restore('src/File.php', staged: true);                          // Index from HEAD
$repo->restore('src/File.php', 'HEAD~1');                              // Worktree from another commit
$repo->restore('src/File.php', 'HEAD~1', staged: true, worktree: true); // Index + worktree from another commit

cherryPick

PHP
public function cherryPick(string $revision): ObjectId
public function cherryPickContinue(): ObjectId
public function cherryPickAbort(): void

Bir commit'i özgün yazarını koruyarak geçerli dalda yeni bir commit olarak uygular. Çakışmalar işlemi durdurursa bunları çözün, yolları hazırlayın, ardından cherryPickContinue() veya cherryPickAbort() çağırın.

PHP
$newId = $repo->cherryPick('feature~2');

// After resolving conflicts:
$repo->add('src/File.php');
$repo->cherryPickContinue();

revert

PHP
public function revert(string $revision): ObjectId
public function revertContinue(): ObjectId
public function revertAbort(): void

Başka bir commit'i geri alan bir commit oluşturur. Çakışmalar revert işlemini durdurursa bunları çözün, yolları hazırlayın, ardından revertContinue() veya revertAbort() çağırın.

PHP
$revertId = $repo->revert('HEAD~1');

// After resolving conflicts:
$repo->add('src/File.php');
$repo->revertContinue();

rebase

PHP
public function rebase(string $onto): array
public function rebaseContinue(): array
public function rebaseAbort(): void
public function rebaseSkip(): array

Geçerli dalı başka bir revizyonun üzerine rebase eder. Pitmaster şu anda çakışmalarda Git biçiminde durma durumuyla doğrusal rebase işlemlerini ve devam etme, iptal etme ve atlama işlemlerini kapsar. HEAD bir dala işaret etmelidir.

rebase(), rebaseContinue() ve rebaseSkip(), rebase'in tamamlanıp tamamlanmadığını, kaç commit'in uygulandığını ve durduğunda çakışan yolları bildiren ['success' => bool, 'commits' => int, 'conflicts' => list<string>] değerini döndürür.

PHP
$result = $repo->rebase('main');

if (!$result['success']) {
    // Resolve conflicts, then continue or skip/abort.
    $repo->add('src/File.php');
    $repo->rebaseContinue();
}

Durum

status

PHP
public function status(): array

Çalışma ağacının durumunu hesaplar. Her biri şunları içeren StatusEntry nesnelerinden oluşan bir dizi döndürür:

  • path: dosya yolu
  • index: HEAD'den indekse değişiklikler için FileStatus enum değeri
  • worktree: indeksten çalışma ağacına değişiklikler için FileStatus enum değeri
  • origPath, renameScore: yeniden adlandırılan girdilerde ayarlanır, aksi hâlde null olur

İzlenmeyen dosyaların her iki sütununda da FileStatus::Untracked bulunur. Yoksayılan dosyalar bildirilmez.

PHP
foreach ($repo->status() as $entry) {
    echo $entry->shortFormat() . "\n"; // "M  src/File.php", "?? notes.txt"
}

statusPorcelainV2

PHP
public function statusPorcelainV2(): string

git'ın porcelain v2 biçiminde makine tarafından okunabilir durum çıktısı.

PHP
echo $repo->statusPorcelainV2();
// 1 M. N... 000000 000000 000000 0000...0000 0000...0000 modified-file.txt
// ? untracked-file.txt

Fark

diff

PHP
public function diff(?string $pathspec = null, string $algorithm = 'myers'): array

Çalışma ağacını indekse göre karşılaştırır (hazırlanmamış değişiklikler). DiffResult nesnelerinden oluşan bir dizi döndürür. $pathspec tek bir tam dosya yoluna göre filtreler. $algorithm, 'myers' (varsayılan), 'patience', 'histogram' veya 'minimal' değeridir; başka herhangi bir değer InvalidArgumentException fırlatır.

PHP
$diffs = $repo->diff();

foreach ($diffs as $diff) {
    echo $diff->format();  // Unified diff output
}

diffStaged

PHP
public function diffStaged(?string $pathspec = null, string $algorithm = 'myers'): array

İndeksi HEAD ile karşılaştırır (hazırlanmış değişiklikler). Silinen ve eklenen dosyalar arasında yeniden adlandırma algılamasıyla DiffResult[] döndürür.

$pathspec bağımsız değişkeni şu anda yok sayılır; bu nedenle hazırlanan her dosya döndürülür ve ilk commit'ten önce yöntem boş bir dizi döndürür (#5).

PHP
$staged = $repo->diffStaged();

diffTree

PHP
public function diffTree(ObjectId $a, ObjectId $b, string $algorithm = 'myers'): array

İki ağacı ObjectId değerlerine göre karşılaştırır. DiffResult[] döndürür. Commit kimlikleri değil, ağaç kimlikleri geçin: commit kimliği ağaç olarak okunmaz ve boş sonuç üretir.

PHP
$old = $repo->readObject($repo->resolve('HEAD~1')->hex);
$new = $repo->head();
$diffs = $repo->diffTree($old->tree, $new->tree);

Günlük

log

PHP
public function log(int $limit = 50, ?ObjectId $from = null): array

Commit geçmişini, commit eden kişinin zaman damgasına göre en yeniden başlayarak tarar. Commit[] döndürür. $from null ise HEAD'den başlar. HEAD'de henüz commit yoksa boş dizi döndürür.

PHP
$commits = $repo->log(10);

logAll

PHP
public function logAll(int $limit = 50): array

Her ref'ten ve HEAD'den erişilebilen commit'leri en yeniden başlayarak tarar. Commit[] döndürür.

logOneline

PHP
public function logOneline(int $limit = 50, bool $all = false, ?string $path = null): array

Günlük satırlarını HEAD'den, tüm ref'lerden ($all) veya bir yola göre filtrelenmiş olarak git log --oneline biçiminde (abc1234 Subject) döndürür.

logPath

PHP
public function logPath(string $path, int $limit = 50): array

Dosya yoluna göre filtrelenmiş günlük. Yalnızca ilk üst öğesine göre farkında tam olarak bu dosyayı ekleyen, değiştiren, silen veya yeniden adlandıran commit'leri döndürür. Dizin yolları eşleşmez.

Yalnızca en yeni 5 * $limit commit incelenir; bu nedenle dosyaya dokunan daha eski commit'ler sonuçta bulunmayabilir (#7).

PHP
$commits = $repo->logPath('src/Repository.php', 20);

Birleştirme

merge

PHP
public function merge(string $branch, string $strategy = 'recursive'): MergeResult
public function mergeOctopus(array $branches): MergeResult
public function mergeContinue(): ObjectId
public function mergeAbort(): void

Bir dalı (veya herhangi bir revizyonu) HEAD ile birleştirir. İleri sarma birleştirmelerini otomatik olarak algılar. İleri sarma olmayan birleştirmelerde ağaç düzeyinde çakışma algılaması yapar ve temizse bir birleştirme commit'i oluşturur. Çakışma durumunda yazma işlemi Git biçimindeki birleştirme durumunu indekse ve çalışma ağacına kaydeder; yolları çözün, hazırlayın, ardından mergeContinue() veya mergeAbort() çağırın.

$strategy 'ours', HEAD'in ağacını koruyan bir birleştirme commit'i kaydeder; başka herhangi bir değer varsayılan özyinelemeli birleştirmeyi kullanır. mergeOctopus(), iki veya daha fazla dalı tek bir commit'te birleştirir. Herhangi bir dalda çakışma varsa, temiz olmayan bir sonuç döndürür ve birleştirme durumunu kaydetmez veya commit oluşturmaz.

Zaten HEAD içinde bulunan bir dalı birleştirmek, "Zaten güncel" bildirmek yerine yeni bir birleştirme commit'i oluşturur (#6). İzlenen dosyalardaki commit edilmemiş değişikliklerin üzerine, checkout() bölümünde açıklandığı gibi yazılır.

Şunları içeren bir MergeResult döndürür:

  • clean: birleştirmenin çakışma olmadan başarılı olup olmadığı
  • commitId: birleştirme commit'inin kimliği (temizse)
  • conflictPaths: çakışan dosya yollarının dizisi (temiz değilse)
  • mergedContents: çakışma işaretçileri içeren dosya içeriğine giden çakışan yol (temiz değilse)
PHP
$result = $repo->merge('feature/login');

if ($result->clean) {
    echo "Merged: {$result->commitId->hex}\n";
} else {
    echo "Conflicts in: " . implode(', ', $result->conflictPaths) . "\n";
    $repo->add('src/File.php');
    $repo->mergeContinue();
}

mergeBase

PHP
public function mergeBase(ObjectId $a, ObjectId $b): ?ObjectId

İki commit'in birleştirme tabanını (en düşük ortak atayı) bulur. Ortak ata yoksa null döndürür.

PHP
$base = $repo->mergeBase(
    $repo->resolve('main'),
    $repo->resolve('feature/login'),
);

İkiye bölme

PHP
public function bisectStart(string $bad, string $good): ObjectId
public function bisectGood(?string $revision = null): ?ObjectId
public function bisectBad(?string $revision = null): ?ObjectId
public function bisectReset(): void

Bir değişikliği başlatan commit'i ikili aramayla bulur. bisectStart() kötü ve iyi revizyonları kaydeder, ilk adayı kullanıma alır ve döndürür. bisectGood() ve bisectBad() geçerli HEAD'i (veya $revision) işaretler, sonraki adayı kullanıma alıp döndürür. Tek bir şüpheli kaldığında, o commit döndürülür ve aday olarak kalır: bu ilk hatalı commit'tir. bisectReset() oturumu bitirir ve başlandığı dala veya commit'e döner.

PHP
$candidate = $repo->bisectStart('HEAD', 'v1.0.0');
// test $candidate ...
$candidate = $repo->bisectBad();
$candidate = $repo->bisectGood();
$repo->bisectReset();

Ağ

fetch

PHP
public function fetch(string $remote = 'origin', ?int $depth = null): void

Bir uzak depodan getirir. Yeni nesneleri indirir ve uzak izleme referanslarını günceller. Sığ geçmişi derinleştirmek veya sınırlamak için $depth kullanın.

fetch() ve push*() yöntemleri, ['processes' => false] ile açılmış bir tanıtıcıda RuntimeException hatası verir.

PHP
$repo->fetch();
$repo->fetch('upstream');

push

PHP
public function push(string $remote = 'origin', ?string $branch = null): void
public function pushForceWithLease(string $remote = 'origin', ?string $branch = null, ?ObjectId $expected = null): void
public function pushAtomic(string $remote = 'origin', array $branches = []): void
public function pushMirror(string $remote = 'origin'): void

Geçerli dalı (veya belirtilen bir dalı) uzak depoya gönderir. Daha sıkı veya kapsamlı referans güncellemeleri için force-with-lease, atomic ve mirror varyantları kullanılabilir.

PHP
$repo->push();
$repo->push('origin', 'feature/login');
$repo->pushForceWithLease('origin', 'main', $repo->resolve('refs/remotes/origin/main'));
$repo->pushAtomic('origin', ['main', 'release']);
$repo->pushMirror();

Çalışma ağaçları

addWorktree

PHP
public function addWorktree(string $path, string $branch, ?ObjectId $from = null, ?string $name = null): Worktree

Bağlantılı bir çalışma ağacı ekler. Dal yoksa oluşturur, çalışma ağacı meta verilerini ayarlar ve çalışma ağacı dosyalarını oluşturur. Ödeme dizininin temel adından farklı, belirleyici bir meta veri slug'ına ihtiyacınız varsa $name kullanın.

PHP
$wt = $repo->addWorktree('/tmp/review', 'feature/review');
$wt = $repo->addWorktree('/tmp/checkouts/review', 'feature/review', name: 'review-wt');

removeWorktree

PHP
public function removeWorktree(string $pathOrName, bool $force = false): void

Bağlantılı bir çalışma ağacını kaldırır. Kilitliyken de kaldırmak için $force = true kullanın.

worktrees

PHP
public function worktrees(): array

Tüm çalışma ağaçlarını (ana + bağlantılı) listeler. Worktree[] döndürür.

PHP
foreach ($repo->worktrees() as $wt) {
    echo "{$wt->path} [{$wt->branch}]\n";
}

Yapılandırma

config

PHP
public function config(): GitConfig

Depo git yapılandırmasına erişir. Yapılandırma değerlerini okur ve yazar.

PHP
$config = $repo->config();
$name = $config->get('user.name');
$config->set('user.email', 'new@example.com');

Dahili erişim

Bu yöntemler, ileri düzey kullanım senaryoları için dahili bileşenleri sunar.

objectDatabase

PHP
public function objectDatabase(): ObjectDatabase

Ham nesne veritabanına erişir (gevşek + paket depoları).

refDatabase

PHP
public function refDatabase(): RefDatabase

Ham ref veritabanına erişir (gevşek + paketlenmiş ref'ler).

Daha düşük düzeyli sınıflar

Bu sınıflar Repository tarafından sarmalanmaz ve onun dahili bileşenlerinden oluşturulur.

Pitmaster\Graph\Blame

PHP
public function blame(ObjectId $headId, string $path): array

$headId konumundaki $path girdilerinden satır başına bir tane döndürür: ['line' => int, 'hash' => string, 'author' => string, 'content' => string]. author tam kimlik dizesidir (Name <email> timestamp timezone).

PHP
use Pitmaster\Graph\Blame;

$blame = new Blame($repo->objectDatabase());

foreach ($blame->blame($repo->resolve('HEAD'), 'src/File.php') as $line) {
    echo substr($line['hash'], 0, 8) . " {$line['content']}\n";
}

Pitmaster\Graph\Grep

PHP
public function grep(ObjectId $treeId, string $pattern, string $prefix = '', array $options = []): array

Bir ağacın blob'larında arama yapar. Eşleşen satır başına ['path' => string, 'line' => int, 'content' => string] döndürür. Seçenekler: regex (deseni PCRE deseni olarak ele alır) ve ignore_case. Geçersiz bir regex, InvalidArgumentException hatasına yol açar.

PHP
use Pitmaster\Graph\Grep;

$grep = new Grep($repo->objectDatabase());
$matches = $grep->grep($repo->head()->tree, 'TODO', '', ['ignore_case' => true]);

Pitmaster\Ref\Notes

PHP
public function get(ObjectId $commitId, string $notesRef = 'refs/notes/commits'): ?string
public function set(ObjectId $commitId, string $noteContent, string $notesRef = 'refs/notes/commits'): void
public function remove(ObjectId $commitId, string $notesRef = 'refs/notes/commits'): void
public function listAll(string $notesRef = 'refs/notes/commits'): array
public function merge(string $sourceRef, string $targetRef = 'refs/notes/commits'): void

Notlar ref'i altında saklanan git notlarını okur ve yazar. listAll(), commit karmasını not içeriğine döndürür.

PHP
use Pitmaster\Ref\Notes;

$notes = new Notes($repo->objectDatabase(), $repo->refDatabase());
$notes->set($repo->resolve('HEAD'), "Reviewed\n");
echo $notes->get($repo->resolve('HEAD'));