Intro to Modules on Go - Part 2

prassee — Sun, 23 Jun 2019 06:12:37 +0000

In the previous post we saw how to init modules, write one, publish it (locally with replace directive) & use it on another Go project / module. This part we are going to publish the module to github and get rid of replace way of aliasing.

Publishing to Github

Publshing to github is a no-brainer just init a git repo and push it to github. However the name of the repo does matters here since the consumers of our module would use that as the identifier.

Lets change the go.mod file on localmod1. So that it points to a proper git repo than just a name.

module github.com/prassee/localmod1

go 1.12

now lets push it to github.

git init . 
git remote add origin git@github.com:prassee/localmod1.git
...
git cm 'initial commit' 
git push origin master

Now the module is published to github. Lets proceed further to use it on other modules.

Using in other modules

This step does not require any coding but we just need to edit go.mod file. Lets open usingmod1 module's
go.mod file.

module usingmod1

replace github.com/prassee/localmod1 => ../localmod1

go 1.12

require github.com/prassee/localmod1 v0.0.0-00010101000000-00000000
0000 // indirect

in the above we just need to replace the 2nd line with the following and updated version should look like below.

module usingmod1
require github.com/prassee/localmod1 v1.0.2
go 1.12

now if we run go mod tidy. we can see its downloading the artifact with the version as we desired.

> go mod tidy
go: finding github.com/prassee/localmod1 v1.0.2
go: downloading github.com/prassee/localmod1 v1.0.2
go: extracting github.com/prassee/localmod1 v1.0.2

Notes

Across this excercise we never used go get command or had any vendor folder to manage our dependenceis.
Modules were written outside the GOPATH.

Thats all folks .... I think I had covered the extent I know about Go Modules.

Intro to Modules on Go - Part 1

prassee — Sat, 22 Jun 2019 15:21:14 +0000

Intro to Modules on Go - Part 1

What are Go modules?

Starting from Go 1.11 'modules' have been introduced to ease / formalize code sharing between Go projects much like other mainstream languages.

Go Modules are very handy way to contain the code into distributable units.
We declare a project as module by using the go mod command. This modules
created can be included as "dependency".

Writing a Go Module

Lets write a module which doubles a number. A Go module is nothing but a simple Go project but that resides outside your $GOPATH. Go modules are initialized in project
with the go mod command. Let create a dir called localmod1 outside $GOPATH
and init module with the command

mkdir localmod1

cd localmod1

go mod init localmod1

This above step creates a go.mod file. It has the below contents.

module localmod1

go 1.12

Create a file called localmod1.go now and put the below code.

package localmod1

import (
"fmt"
)

func DblX(x int) int {
fmt.Printf("dboubling %v", x)
return x * 2
}

now our module is ready with some real code. Next step is to consume it so that we prepare it for other modules to use them.

Using published module in another Go module

Modules can be consumed in two ways either from local or directly from github. Though the latter is the most recommended however, on some cases it make sense (and useful) to treat as if they are published locally.

Lets create another module say usingmod1 which uses localmod1.

mkdir usingmod1

cd usingmod1

go mod init usingmod1

like before the above step creates a empty go.mod file as shown below

module usingmod1
go 1.12

local

Now lets use the 'localmod1' by adding it as a dependency. Since localmod1 is still in our local but we can assume that its been published to github thereby creating an alias pointing to location of localmod1 absolute path. Add the following lines to go.mod

    require github.com/prassee/localmod1 v0.0.0
    replace github.com/prassee/localmod1 => ../localmod1

here the git repo github.com/prassee/localmod1 is an imaginary or yet to create location. After adding lets run go mod tidy command to let go to formalize our dependency definition. The upadted version look like below.

    module usingmod1
    replace github.com/prassee/localmod1 => ../localmod1
    go 1.12
    require github.com/prassee/localmod1 v0.0.0-00010101000000-000000000000 // indirect

Now we are all set to use the imported module in our code. In main.go add the following lines.

    package main

    import (
        "fmt"
        "github.com/prassee/localmod1"
    )
    func main() {
        fmt.Printf("using mod1")
        localmod1.DblX(23)
    }

Thats for now. In the next part we can explore how to publish a module in to Github .

until then enjoy Go modules ...

References

Iam still picking up Go here are the references I've used to learn myself writing Go modules.

https://roberto.selbach.ca/intro-to-go-modules/

DEV Community: prassee

Intro to Modules on Go - Part 2

Intro to Modules on Go - Part 1

Intro to Modules on Go - Part 1