¿Cuál es la organización correcta para los proyectos de Go que usan Git (o cualquier VCS)?

Question

Mi GOPATH es /Users/joe/go. Estoy trabajando en un proyecto llamado myproj, que es un paquete llamado myproj.

Si quiero ser capaz de escribir import "myproj" entonces la estructura de directorios que necesito es:

$GOPATH/src/myproj/myproj.go 
$GOPATH/src/myproj/myproj_test.go 
... 

Sin embargo, me parece que no puede hacer este ajuste con Git. Si miro un example package from Google veo el siguiente formato:

go.example/hello/hello.go 
go.example/LICENSE 

Dónde go.example es el nombre de la cesión temporal.

Por lo tanto, los directorios del paquete real se encuentran dentro de el repositorio. Si pongo el contenido de este repositorio en un directorio en mi $ GOPATH, p.

$GOPATH/src/go.example/hello/hello.go 
$GOPATH/src/go.example/LICENSE 

entonces voy a tener que escribir import "go.example/hello" en lugar de import "hello".

Volviendo a mi proyecto, necesito empaquetarlo en un repositorio de Git y luego necesito un directorio de contenedores. Así que mi estructura de archivos actual es:

$GOPATH/src/myproj      # The dir for the git repo 
$GOPATH/src/myproj/.git 
$GOPATH/src/myproj/LICENSE    # Files in the base of the repo 
$GOPATH/src/myproj/myproj/myproj.go  # Package files in package dir 
$GOPATH/src/myproj/myproj/myproj_test.go 

necesito el directorio myproj exterior para delimitar el repositorio git y necesito el interior para ser el directorio del paquete. El resultado es que necesito escribir import "myproj/myproj" en lugar de import "myproj".

¿cómo puedo solucionar esto? ¿Tengo que agregar varios $ GOPATHS, uno por cada proyecto que estoy desarrollando?

Gracias de antemano.

Answer 1

En primer lugar:

¿Tengo que añadir múltiples $GOPATH s, uno para cada proyecto que estoy desarrollando?

No, no necesita múltiples $GOPATH s en absoluto.

Son una herramienta para administrar sus (potencialmente varios) proyectos.Cuando configura un nuevo entorno de proyecto que ya sabe que tendrá algunas dependencias, potencialmente únicas para ese proyecto, o que deberían ser similares a las configuraciones de otras personas, cree una nueva carpeta de proyecto y configúrela como GOPATH. De esta forma, también puede usar (= verificar) versiones específicas de una biblioteca para ese proyecto, mientras usa otras versiones para sus otros proyectos en otras carpetas de proyecto (= GOPATH s).

En cuanto a su problema de ruta: Ir sigue un paradigma genérico de author/project (o organization/project). Esto evitará el nombramiento de conflictos cuando varias personas, autores y organizaciones, inicien proyectos con los mismos nombres. (El autor puede entonces utilizar sub-carpetas, sub-proyectos en “su” carpeta, así OFC.)

Si usted es consciente de esto y todavía conviene usar myproj como su ruta del paquete, hay no hay problema al crear el repositorio de git en esa carpeta - contrario al paquete de ejemplo al que se ha vinculado.

Volviendo a mi proyecto, necesito empaquetarlo en un repositorio de Git y luego necesito un directorio de contenedores.

¿Qué te hace pensar eso? Ir no lo necesita. Git no hace ninguno.

Así que el siguiente trabajo:

/src/myproj/.git 
/src/myproj/myproj.go 

Si bien no es la práctica animado, usted puede poner el repositorio en su carpeta myproj.

---

He probado esto como sigue:

FOLDER 
FOLDER/src 
FOLDER/src/myproj 
FOLDER/src/myproj/myproj.go 
FOLDER/src/mainproj 
FOLDER/src/mainproj/main.go 

Con folder/src/myproj/myproj.go

package myproj 

type My struct { 
    I int 
} 

y folder/src/mainproj/main.go

package main 

import (
    "fmt" 
    "myproj" 
) 

func main() { 
    my := myproj.My{7} 
    fmt.Printf("Works! %v", my.I) 
} 

Correr

cd FOLDER 
set GOPATH=FOLDER 
go run src/mainproj/main.go 

la Salida:

Works! 7 

Ahora, si git init en la carpeta FOLDER/src/myproj, eso no importa a ir sí en absoluto.

Answer 2

La configuración habitual es la siguiente:

$ GOPATH, en la primera aproximación necesita sólo un camino, su ejemplo es /Users/joe/go/ bien. Ahora tiene un repositorio de github myproj visto en http://github.com/joe/myproj. La declaración de importación de este paquete debe ser

import "github.com/joe/myproj" 

Mirando hacia atrás en su (solo valor) $ GOPATH, la herramienta Ir buscará su paquete en $GOPATH/src/github.com/joe/myproj y esa es la raíz "local" de su repositorio GitHub "externa" con archivos myproj.go, etc.go, ... adentro.

Sin estas convenciones habrá conflictos de espacio de nombres con los proyectos de Jack (y de Alice y Bob) llamados accidentalmente también myproj, por lo que recomiendo acostumbrarse a esto desde el principio.

Answer 3

Usted, naturalmente importar varios paquetes:

• los estándar
• unos pocos podrás descargar con go get
• unos pocos en su proyecto
• unos pocos en otra proyectos

Lo más simple es elegir un directorio donde go get todo los paquetes externos (driver mysql por ejemplo) y agregue los directorios de sus proyectos a GOPATH.

Por ejemplo, aquí es mi (simplificado) GOPATH:

export GOPATH=/home/dys/dev/go:/home/dys/dev/Chrall/go:/home/dys/dev/braldop/go:/home/dys/dev/lg/go 

puse todas las bibliotecas externas obtenidos usando go get en /home/dys/dev/go y Chrall, braldop y LG son 3 de mis proyectos.

En cada uno de esos 3 proyectos, tengo paquetes y comandos. Por ejemplo:

/home/dys/dev/lg/go/src/pkg1/xxx.go 
/home/dys/dev/lg/go/src/pkg2/xxx.go 
/home/dys/dev/lg/go/src/prog1/xxx.go 

etc.

Todos los paquetes se encuentran a través de GOPATH.

Por ejemplo cuando se utiliza un controlador de MySQL, en uno de esos xxx.go:

import (
"database/sql" 
_ "github.com/ziutek/mymysql/godrv" 
) 

El controlador se ha instalado en/home/dis/dev/ir utilizando

go get github.com/ziutek/mymysql/godrv 

Referencia:http://golang.org/doc/code.html

GOPATH =/home/usuario/ext:/home/usuario/Mygo

(En un sistema Windows utilizan punto y coma como separador de ruta en lugar de dos puntos.)

Cada ruta en la lista (en este caso/home/usuario/ext o/home/usuario/Mygo) especifica la ubicación de un espacio de trabajo. Un espacio de trabajo contiene archivos Go source y sus objetos de paquete asociados, y comandos ejecutables.