What's the correct organisation for Go projects using Git (or any VCS)?

Question

My GOPATH is `/Users/joe/go`. I am working on a project called `myproj`, which is a package called `myproj`. If I want to be able to write `import "myproj"` then the directory structure I need is: ``` $GOPATH/src/myproj/myproj.go $GOPATH/src/myproj/myproj_test.go ... ``` However, I can't seem to make this fit with Git. If I look at an example package from Google I see the following format: ``` go.example/hello/hello.go go.example/LICENSE ``` Where `go.example` is the name of the repo. So the actual package directories are found inside the repository. If I put the contents of this repository in a directory on my $GOPATH, e.g. ``` $GOPATH/src/go.example/hello/hello.go $GOPATH/src/go.example/LICENSE ``` then I will have to type `import "go.example/hello"` rather than `import "hello"`. Coming back to my project, I need to package this up in a Git repository then I need a container directory. So my current file structure is: ``` $GOPATH/src/myproj # The dir for the git repo $GOPATH/src/myp…

Accepted Answer

First off:

Do I have to add multiple `$GOPATH`s, one for each project I'm developing?

No, you don’t need multiple `$GOPATH`s at all.

They are a tool for managing your (potentially several) projects. When you set up a new project environment which you already know will have some dependencies - potentially unique to that project, or which should be similiar to other peoples setups, you create a new project folder and set it as the `GOPATH`. That way, you can also use (= check out) specific versions of a library for that project, while using other versions for your other projects in other project folders (= `GOPATH`s).

As for your path issue: Go follows a generic paradigm of `author/project` (or `organization/project`). This will prevent naming clashes when several people, authors and organizations, start projects with the same names. (The author may then use sub-folders, sub-projects in “his” folder as well ofc.)

If you are aware of this and still want to use only `myproj` as your package path, there is no problem in creating the git repository in that folder - in contrary to the example package you linked to.

Coming back to my project, I need to package this up in a Git repository then I need a container directory.

What makes you think so then? Go does not need it. Git does neither.

So the following will work:

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

While it is not the encouraged practice, you can put the repository into your `myproj` folder.

I tested this as follows:

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

With `folder/src/myproj/myproj.go`

```
package myproj

type My struct {
    I int
}
```

and `folder/src/mainproj/main.go`

```
package main

import (
    "fmt"
    "myproj"
)

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

Running

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

will output:

```
Works! 7
```

Now, if you `git init` in the folder `FOLDER/src/myproj`, that does not matter to Go itself at all.

What's the correct organisation for Go projects using Git (or any VCS)?

Solution

Problem

Related problems