Angenommen, Sie haben ein Repository in github.com/someone/repound geben es an github.com/you/repo. Sie möchten Ihre Gabel anstelle des Haupt-Repos verwenden, also tun Sie a

go get github.com/you/repo

Jetzt werden alle Importpfade in diesem Repo "unterbrochen". Wenn sich also mehrere Pakete im Repository befinden, die über absolute URLs aufeinander verweisen, verweisen sie auf die Quelle und nicht auf die Abzweigung.

Gibt es einen besseren Weg, als es manuell in den richtigen Pfad zu klonen?

git clone git@github.com:you/repo.git $GOPATH/src/github.com/someone/repo

Pull-Anfragen bearbeiten

• Fork ein Repository github.com/someone/repozugithub.com/you/repo
• Originalcode herunterladen: go get github.com/someone/repo
• da sein: cd "$(go env GOPATH)/src"/github.com/someone/repo
• Aktivieren Sie das Hochladen auf Ihre Gabel: git remote add myfork https://github.com/you/repo.git
• Laden Sie Ihre Änderungen in Ihr Repo hoch: git push myfork

http://blog.campoy.cat/2014/03/github-and-go-forking-pull-requests-and.html

So verwenden Sie ein Paket in Ihrem Projekt

https://github.com/golang/go/wiki/PackageManagementTools

Wenn Sie go-Module verwenden . Sie könnten die replaceDirektive verwenden

Mit der replaceAnweisung können Sie einen anderen Importpfad angeben, bei dem es sich möglicherweise um ein anderes Modul in VCS (GitHub oder anderswo) oder in Ihrem lokalen Dateisystem mit einem relativen oder absoluten Dateipfad handelt. Der neue Importpfad aus der replaceDirektive wird verwendet, ohne dass die Importpfade im eigentlichen Quellcode aktualisiert werden müssen.

Sie können dies also unten in Ihrer go.mod-Datei tun

module github.com/yogeshlonkar/openapi-to-postman

go 1.12

require (
    github.com/someone/repo v1.20.0
)

replace github.com/someone/repo => github.com/you/repo v3.2.1

Wo v3.2.1ist das Tag auf deinem Repo? Kann auch über die CLI erfolgen

go mod edit -replace="github.com/someone/repo@v0.0.0=github.com/you/repo@v1.1.1"

Eine Möglichkeit, dies zu lösen, ist die von Ivan Rave und http://blog.campoy.cat/2014/03/github-and-go-forking-pull-requests-and.html vorgeschlagene Methode zum Gabeln.

Eine andere Möglichkeit besteht darin, das Golang- Verhalten zu umgehen . Wenn Sie go get, golang Ihre Verzeichnisse unter demselben Namen enthalten, wie es in dem Repository - URI und das ist , wo das Problem beginnt.

Wenn Sie stattdessen Ihr eigenes git cloneRepository ausgeben , können Sie Ihr Repository unter einem Pfad, der nach dem ursprünglichen Repository benannt ist, auf Ihr Dateisystem klonen.

Angenommen, das ursprüngliche Repository befindet sich github.com/awsome-org/toolund Sie teilen es auf github.com/awesome-you/tool, können Sie:

cd $GOPATH
mkdir -p {src,bin,pkg}
mkdir -p src/github.com/awesome-org/
cd src/github.com/awesome-org/
git clone git@github.com:awesome-you/tool.git # OR: git clone https://github.com/awesome-you/tool.git
cd tool/
go get ./...

golang ist vollkommen glücklich, mit diesem Repository fortzufahren, und es ist ihm eigentlich egal, ob ein oberes Verzeichnis den Namen hat, awesome-orgwährend sich die Git-Fernbedienung befindet awesome-you. Alle Importe für awesome-orgwerden über das soeben erstellte Verzeichnis, das Ihr lokaler Arbeitssatz ist, erneut erstellt.

Weitere Informationen finden Sie in meinem Blogbeitrag: Forken von Golang-Repositorys auf GitHub und Verwalten des Importpfads

edit : fester Verzeichnispfad

Wenn Ihre Gabel nur vorübergehend ist (dh Sie beabsichtigen, sie zusammenzuführen), führen Sie Ihre Entwicklung einfach in situ durch, z $GOPATH/src/launchpad.net/goamz.

Anschließend verwenden Sie die Funktionen des Versionskontrollsystems (z. B. git remote), um das Upstream-Repository zu Ihrem Repository und nicht zum ursprünglichen Repository zu machen.

Dies erschwert es anderen Personen, Ihr Repository zu verwenden go get, erleichtert jedoch die Integration in das Upstream.

Tatsächlich habe ich ein Repository für Goamz lp:~nick-craig-wood/goamz/goamz, für das ich genau so entwickle. Vielleicht wird der Autor es eines Tages zusammenführen!

Hier ist ein Weg, der für alle funktioniert:

Verwenden Sie Github, um zu "my / repo" zu wechseln (nur ein Beispiel):

go get github.com/my/repo
cd ~/go/src/github.com/my/repo
git branch enhancement
rm -rf .
go get github.com/golang/tools/cmd/gomvpkg/…
gomvpkg <<oldrepo>> ~/go/src/github.com/my/repo
git commit

Wiederholen Sie diesen Vorgang jedes Mal, wenn Sie den Code verbessern:

git commit
git checkout enhancement
git cherry-pick <<commit_id>>
git checkout master

Warum? Auf diese Weise können Sie Ihr Repo haben, mit dem jedes go getfunktioniert. Außerdem können Sie einen Zweig pflegen und erweitern, der für eine Pull-Anfrage geeignet ist. Es bläht sich nicht mit "Vendor" auf, es bewahrt die Geschichte und Build-Tools können Sinn machen.

Die Antwort darauf lautet: Wenn Sie ein Repo mit mehreren Paketen teilen, müssen Sie alle relevanten Importpfade umbenennen. Dies ist größtenteils eine gute Sache, da Sie alle diese Pakete gegabelt haben und die Importpfade dies widerspiegeln sollten.

Um diesen Prozess zu automatisieren, habe ich ein kleines Skript geschrieben. Weitere Details finden Sie in meinem Blog , um Ihrer Bash einen Befehl wie "gofork" hinzuzufügen.

function gofork() {
  if [ $# -ne 2 ] || [ -z "$1" ] || [ -z "$2" ]; then
    echo 'Usage: gofork yourFork originalModule'
    echo 'Example: gofork github.com/YourName/go-contrib github.com/heirko/go-contrib'
    return
  fi
   echo "Go get fork $1 and replace $2 in GOPATH: $GOPATH"
   go get $1
   go get $2
   currentDir=$PWD
   cd $GOPATH/src/$1
   remote1=$(git config --get remote.origin.url)
   cd $GOPATH/src/$2
   remote2=$(git config --get remote.origin.url)
   cd $currentDir
   rm -rf $GOPATH/src/$2
   mv $GOPATH/src/$1 $GOPATH/src/$2
   cd $GOPATH/src/$2
   git remote add their $remote2
   echo Now in $GOPATH/src/$2 origin remote is $remote1
   echo And in $GOPATH/src/$2 their remote is $remote2
   cd $currentDir
}

export -f gofork

Verwenden Sie Vendoring und Submodule zusammen

1. Fork die lib auf github (in diesem Fall go-mssqldb)
2. Fügen Sie ein Submodul hinzu, das Ihre Gabel in Ihren Lieferantenordner klont, aber den Pfad des Upstream-Repos enthält
3. Aktualisieren Sie Ihre importAnweisungen in Ihrem Quellcode so, dass sie auf den Herstellerordner verweisen (ohne vendor/Präfix). ZB vendor/bob/lib=>import "bob/lib"

Z.B

cd ~/go/src/github.com/myproj

mygithubuser=timabell
upstreamgithubuser=denisenkom
librepo=go-mssqldb

git submodule add "git@github.com:$mygithubuser/$librepo" "vendor/$upstreamgithubuser/$librepo"

Warum

Dies löst alle Probleme, von denen ich gehört habe und auf die ich gestoßen bin, während ich versucht habe, dies selbst herauszufinden.

• Interne Paketreferenzen in der Bibliothek funktionieren jetzt, da der Pfad vom Upstream unverändert bleibt
• Ein neues Auschecken Ihres Projekts funktioniert, da das Submodul-System es beim richtigen Festschreiben, jedoch im Pfad des vorgelagerten Ordners, von Ihrem Fork erhält
• Sie müssen nicht wissen, wie Sie die Pfade manuell hacken oder mit den Go-Werkzeugen herumspielen.

Mehr Info

• https://git-scm.com/book/en/v2/Git-Tools-Submodules
• Wie behebe ich die Fehlermeldung "Verwendung eines internen Pakets nicht erlaubt", wenn ich ein Golang-Paket erhalte?
• https://github.com/denisenkom/go-mssqldb/issues/406
• https://github.com/golang/go/wiki/PackageManagementTools#go15vendorexperiment

Fügen Sie in Ihrer Gopkg.tomlDatei diesen Block unten hinzu

[[constraint]]
  name = "github.com/globalsign/mgo"
  branch = "master"
  source = "github.com/myfork/project2"

Also wird es die Gabel project2anstelle von verwendengithub.com/globalsign/mgo

Sie können den Befehl verwenden go get -f, um ein gegabeltes Repo zu erhalten