Suponga que tiene un repositorio en github.com/someone/repoy lo bifurca a github.com/you/repo. Quieres usar tu fork en lugar del repositorio principal, entonces haces un

go get github.com/you/repo

Ahora todas las rutas de importación en este repositorio estarán "rotas", lo que significa que si hay varios paquetes en el repositorio que hacen referencia entre sí a través de URL absolutas, harán referencia a la fuente, no a la bifurcación.

¿Existe una mejor manera de clonarlo manualmente en la ruta correcta?

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

Para manejar solicitudes de extracción

• bifurcar un repositorio github.com/someone/repoparagithub.com/you/repo
• descargar código original: go get github.com/someone/repo
• estar ahí: cd "$(go env GOPATH)/src"/github.com/someone/repo
• habilite la carga en su fork: git remote add myfork https://github.com/you/repo.git
• cargue sus cambios en su repositorio: git push myfork

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

Para usar un paquete en su proyecto

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

Si está utilizando módulos go . Podrías usar replacedirectiva

La replacedirectiva le permite proporcionar otra ruta de importación que podría ser otro módulo ubicado en VCS (GitHub o en otro lugar), o en su sistema de archivos local con una ruta de archivo relativa o absoluta. La nueva ruta de importación de la replacedirectiva se utiliza sin necesidad de actualizar las rutas de importación en el código fuente real.

Entonces podría hacerlo a continuación en su archivo go.mod

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

dónde v3.2.1está la etiqueta en su repositorio. También se puede hacer a través de CLI

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

Una forma de resolverlo es la sugerida por Ivan Rave y http://blog.campoy.cat/2014/03/github-and-go-forking-pull-requests-and.html - la forma de bifurcación.

Otro es solucionar el comportamiento de golang . Cuando usted go get, golang coloca sus directorios con el mismo nombre que en el URI del repositorio, y aquí es donde comienza el problema.

Si, en cambio, emite el suyo propio git clone, puede clonar su repositorio en su sistema de archivos en una ruta con el nombre del repositorio original.

Suponiendo que el repositorio original está dentro github.com/awsome-org/tooly lo bifurca github.com/awesome-you/tool, puedes:

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 está perfectamente feliz de continuar con este repositorio y en realidad no le importa que algún directorio superior tenga el nombre, awesome-orgmientras que el git remote lo es awesome-you. Todas las importaciones awesome-orgse resuelven a través del directorio que acaba de crear, que es su conjunto de trabajo local.

Más detalladamente , consulte la publicación de mi blog: Bifurcación de repositorios de Golang en GitHub y administración de la ruta de importación

editar : ruta de directorio fija

Si su bifurcación es solo temporal (es decir, tiene la intención de fusionarlo), simplemente haga su desarrollo in situ, por ejemplo, en $GOPATH/src/launchpad.net/goamz .

A continuación, utiliza las funciones del sistema de control de versiones (p. Ej. git remote ) para hacer que el repositorio ascendente sea su repositorio en lugar del original.

Hace que sea más difícil para otras personas usar su repositorio con go get pero es mucho más fácil integrarlo en sentido ascendente.

De hecho, tengo un repositorio de goamz en el lp:~nick-craig-wood/goamz/goamzque desarrollo exactamente de esa manera. ¡Quizás el autor lo combine algún día!

Aquí hay una forma de que funcione para todos:

Use github para bifurcar a "mi / repositorio" (solo un ejemplo):

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

Repita cada vez que mejore el código:

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

¿Por qué? Esto le permite tener su repositorio con el que cualquiera go getfunciona. También le permite mantener y mejorar una rama que es buena para una solicitud de extracción. No hincha git con "proveedor", conserva el historial y las herramientas de compilación pueden darle sentido.

La respuesta a esto es que si bifurca un repositorio con varios paquetes, deberá cambiar el nombre de todas las rutas de importación relevantes. Esto es en gran parte algo bueno ya que ha bifurcado todos esos paquetes y las rutas de importación deberían reflejar esto.

Para automatizar este proceso, escribí un pequeño script. Puedes encontrar más detalles en mi blog para agregar un comando como "gofork" a tu bash.

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

Utilice proveedores y submódulos juntos

1. Bifurque la lib en github (go-mssqldb en este caso)
2. Agregue un submódulo que clone su bifurcación en la carpeta de su proveedor pero que tenga la ruta del repositorio ascendente
3. Actualice sus importdeclaraciones en su código fuente para que apunten a la carpeta del proveedor (sin incluir el vendor/prefijo). Por ejemplo vendor/bob/lib=>import "bob/lib"

P.ej

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

mygithubuser=timabell
upstreamgithubuser=denisenkom
librepo=go-mssqldb

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

Por qué

Esto resuelve todos los problemas de los que he oído hablar y con los que me he encontrado al tratar de resolverlo yo mismo.

• Las referencias de paquetes internos en la biblioteca ahora funcionan porque la ruta no ha cambiado desde el origen
• Una nueva comprobación de su proyecto funciona porque el sistema de submódulos lo obtiene de su bifurcación en la confirmación correcta pero en la ruta de la carpeta ascendente
• No tiene que saber cortar manualmente los caminos o meterse con las herramientas de Go.

Más información

• https://git-scm.com/book/en/v2/Git-Tools-Submodules
• ¿Cómo soluciono el mensaje de error "no se permite el uso de un paquete interno" cuando obtengo un paquete golang?
• https://github.com/denisenkom/go-mssqldb/issues/406
• https://github.com/golang/go/wiki/PackageManagementTools#go15vendorexperiment

en su Gopkg.tomlarchivo agregue estos bloques a continuación

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

Entonces usará el bifurcado project2en lugar degithub.com/globalsign/mgo

Puede usar el comando go get -fpara obtener un repositorio bifurcado