Come posso verificare una richiesta pull di GitHub con git?

Vorrei dare un'occhiata a una richiesta pull precedentemente creata (creata tramite l'interfaccia web di GitHub). Ho cercato e trovato diversi posti in cui refs / pull o refs / pull / pr

Ma quando aggiungo fetch = +refs/pull/*/head:refs/remotes/origin/pr/*al file config git e faccio un recupero git

Cosa sto facendo di sbagliato? GitHub dovrebbe creare automaticamente le cose pull / xyz o devo configurare qualcosa?

Per recuperare un PR remoto nel repository locale,

git fetch origin pull/ID/head:BRANCHNAME

dove si IDtrova l'id richiesta pull ed BRANCHNAMEè il nome del nuovo ramo che si desidera creare. Dopo aver creato il ramo, semplicemente

git checkout BRANCHNAME

Consulta la documentazione ufficiale di GitHub per ulteriori informazioni.

Questo verrà recuperato senza che tu debba nominare un ramo:

git pull origin pull/939/head

Come posso ottenere una richiesta pull specifica sulla mia macchina?

Quella sostanza descrive cosa succede quando esegui un recupero git:

Ovviamente, modifica l'URL di Github in modo che corrisponda all'URL del tuo progetto. Finisce così:

[remote "origin"]
    fetch = +refs/heads/*:refs/remotes/origin/*
    url = git@github.com:joyent/node.git
    fetch = +refs/pull/*/head:refs/remotes/origin/pr/*

Ora recupera tutte le richieste pull:

$ git fetch origin
From github.com:joyent/node
 * [new ref]         refs/pull/1000/head -> origin/pr/1000
 * [new ref]         refs/pull/1002/head -> origin/pr/1002
 * [new ref]         refs/pull/1004/head -> origin/pr/1004
 * [new ref]         refs/pull/1009/head -> origin/pr/1009
...

Per verificare una particolare richiesta pull:

$ git checkout pr/999
Branch pr/999 set up to track remote branch pr/999 from origin.
Switched to a new branch 'pr/999'

Sono disponibili vari script elencati nei numeri 259 per automatizzare tale attività.
Il progetto git-extra propone il comando git-pr(implementato in PR 262 )

git-pr(1) - Verifica una richiesta pull localmente

SINOSSI

git-pr <number> [<remote>]
git-pr clean

DESCRIZIONE

Crea un ramo locale basato su un numero di richiesta pull di GitHub e successivamente passa a quel ramo.

Il nome del telecomando da cui recuperare. L'impostazione predefinita è origin.

ESEMPI

Questo verifica la richiesta pull 226da origin:

$ git pr 226

remote: Counting objects: 12, done.
remote: Compressing objects: 100% (9/9), done.
remote: Total 12 (delta 3), reused 9 (delta 3)
Unpacking objects: 100% (12/12), done.
From https://github.com/visionmedia/git-extras
  * [new ref] refs/pull/226/head -> pr/226
Switched to branch 'pr/226'

Preferisco recuperare e fare il checkout senza creare un ramo locale ed essere in stato distaccato HEAD . Mi consente di controllare rapidamente la richiesta pull senza inquinare il mio computer locale con filiali locali non necessarie.

git fetch upstream pull/ID/head && git checkout FETCH_HEAD

dove IDè un ID richiesta pull e upstreamdove è stata creata la richiesta pull originale (potrebbe essere origin, ad esempio).

Spero possa essere d'aiuto.

Facendo riferimento alla risposta di Steven Penny, è meglio creare un ramo di prova e testare il PR. Quindi, ecco cosa faresti.

1. Creare un ramo di prova in cui unire il PR in locale. Supponendo che tu sia nel ramo principale:

git checkout -b test

2. Ottieni le modifiche PR nel ramo di test

git pull origin pull/939/head:test

Ora puoi testare in sicurezza le modifiche su questo ramo di test locale (in questo caso, denominato test ) e una volta che sei soddisfatto, puoi unirlo come al solito da GitHub.

Se stai utilizzando Github.com, vai su "Richieste pull", fai clic sulla relativa richiesta pull, quindi fai clic sul link "Istruzioni da riga di comando":

È possibile utilizzare il git configcomando per scrivere una nuova regola .git/configper recuperare le richieste pull dal repository:

$ git config --local --add remote.origin.fetch '+refs/pull/*/head:refs/remotes/origin/pr/*'

E poi solo:

$ git fetch origin
Fetching origin
remote: Counting objects: 4, done.
remote: Compressing objects: 100% (2/2), done.
remote: Total 4 (delta 2), reused 4 (delta 2), pack-reused 0
Unpacking objects: 100% (4/4), done.
From https://github.com/container-images/memcached
 * [new ref]         refs/pull/2/head -> origin/pr/2
 * [new ref]         refs/pull/3/head -> origin/pr/3

Il problema con alcune delle opzioni sopra, è che se qualcuno spinge più commit sul PR dopo aver aperto il PR, non ti darà la versione più aggiornata. Per me quello che ha funzionato meglio è: vai su PR e premi 'Commits', scorri verso il basso per vedere l'ultimo hash di commit e poi usa semplicemente git checkout, cioè

git checkout <commit number>

nell'esempio sopra

git checkout 0ba1a50

Sto usando hub, uno strumento di github: https://github.com/github/hub

Con l'hub che verifica una richiesta pull localmente è abbastanza semplice:

hub checkout https://github.com/owner/repo/pull/1234
or
hub pr checkout 1234

Per Bitbucket, è necessario sostituire la parola pullin pull-requests.

Innanzitutto, è possibile confermare lo stile dell'URL della richiesta pull tramite git ls-remote origincomando.

$ git ls-remote origin |grep pull
f3f40f2ca9509368c959b0b13729dc0ae2fbf2ae    refs/pull-requests/1503/from
da4666bd91eabcc6f2c214e0bbd99d543d94767e    refs/pull-requests/1503/merge
...

Come puoi vedere, è refs/pull-requests/1503/frominvece direfs/pull/1503/from

Quindi è possibile utilizzare i comandi di una qualsiasi delle risposte.

Ho finito per scrivere quasi lo stesso di quello fornito da git-extra. Quindi se preferisci un singolo comando personalizzato invece di installare un mucchio di altri comandi extra, posiziona questo git-prfile da qualche parte nel tuo $PATHe quindi puoi semplicemente scrivere:

git pr 42
// or
git pr upstream 42
// or
git pr https://github.com/peerigon/phridge/pull/1

Se stai seguendo il flusso di lavoro "github fork", dove crei un fork e aggiungi il repository upstream remoto:

14:47 $ git remote -v
origin  git@github.com:<yourname>/<repo_name>.git (fetch)
origin  git@github.com:<yourname>/<repo_name>.git (push)
upstream        git@github.com:<repo_owrer>/<repo_name>.git (fetch)
upstream        git@github.com:<repo_owner>/<repo_name>.git (push)

per inserire nel tuo ramo attuale il tuo comando sarebbe simile a:

git pull upstream pull/<pull_request_number>/head

per inserire in un nuovo ramo il codice sarebbe simile a:

git fetch upstream pull/<pull_request_number>/head:newbranch

Github ha recentemente rilasciato un'utilità cli chiamata github-cli . Dopo averlo installato, puoi verificare localmente il ramo di una richiesta pull usando il suo ID

per esempio: gh pr checkout 2267

Si noti che questo pacchetto è ancora in versione beta

Porta il ramo PR remoto nel ramo locale:

git fetch origin ‘remote_branch’:‘local_branch_name’

Impostare l'upstream del ramo locale su ramo remoto.

git branch --set-upstream-to=origin/PR_Branch_Name local_branch

Quando si desidera inviare nuovamente le modifiche locali al ramo PR

git push origin HEAD:remote_PR_Branch_name

Supponiamo che la tua origine e le informazioni a monte siano come di seguito

   $ git remote -v
   origin  git@github.com:<yourname>/<repo_name>.git (fetch)
   origin  git@github.com:<yourname>/<repo_name>.git (push)
   upstream   git@github.com:<repo_owner>/<repo_name>.git (fetch)
   upstream   git@github.com:<repo_owner>/<repo_name>.git (push)

e il nome della tua filiale è come

   <repo_owner>:<BranchName>

poi

   git pull origin <BranchName>

deve fare il lavoro

Se i loro commit sono sul ramo principale del loro repository biforcato, puoi semplicemente fare quanto segue.

git fetch git@github.com:<repo_owner>/<repo_name>.git
git checkout FETCH_HEAD