Have travis work from bazel 0.4.2 as that is the oldest version we will support. (#256)

2 files changed
tree: f9eb9b12b6ca8aabfb88300e327ce32649648034
  1. examples/
  2. go/
  3. proto/
  4. .gitignore
  5. .travis.yml
  6. AUTHORS
  7. BUILD
  8. CONTRIBUTING.md
  9. CONTRIBUTORS
  10. LICENSE.txt
  11. README.md
  12. Vendoring.md
  13. WORKSPACE
README.md

Go rules

Bazel ≥0.3.1linux-x86_64ubuntu_15.10-x86_64darwin-x86_64
Build StatusBuild StatusBuild StatusBuild Status

Overview

The rules should be considered experimental. They support:

  • libraries
  • binaries
  • tests
  • vendoring
  • cgo
  • auto generating BUILD files via gazelle
  • protocol buffers (via extension //proto:go_proto_library.bzl)

They currently do not support (in order of importance):

  • build constraints/tags (//+build comments - see here))
  • bazel-style auto generating BUILD (where the library name is other than go_default_library)
  • C/C++ interoperation except cgo (swig etc.)
  • race detector
  • coverage
  • test sharding

Note: this repo requires bazel >= 0.4.2 to function (due to the use of BUILD.bazel files)

Setup

  • Decide on the name of your package, eg. github.com/joe/project

  • Add the following to your WORKSPACE file:

    git_repository(
        name = "io_bazel_rules_go",
        remote = "https://github.com/bazelbuild/rules_go.git",
        tag = "0.4.0",
    )
    load("@io_bazel_rules_go//go:def.bzl", "go_repositories")
    
    go_repositories()
    
  • Add a BUILD file to the top of your workspace, declaring the name of your workspace using go_prefix. This prefix is used for Go‘s “import” statements to refer to packages within your own project, so it’s important to choose a prefix that might match the location that another user might choose to put your code into.

    load("@io_bazel_rules_go//go:def.bzl", "go_prefix")
    
    go_prefix("github.com/joe/project")
    
  • For a library github.com/joe/project/lib, create lib/BUILD, containing a single library with the special name “go_default_library.” Using this name tells Bazel to set up the files so it can be imported in .go files as (in this example) github.com/joe/project/lib.

    load("@io_bazel_rules_go//go:def.bzl", "go_library")
    
    go_library(
        name = "go_default_library",
        srcs = ["file.go"]
    )
    
  • Inside your project, you can use this library by declaring a dependency on the full Bazel name (including :go_default_library), and in the .go files, import it as shown above.

    go_binary(
        ...
        deps = ["//lib:go_default_library"]
    )
    
  • To declare a test,

    go_test(
        name = "mytest",
        srcs = ["file_test.go"],
        library = ":go_default_library"
    )
    
  • For instructions on how to depend on external libraries, see Vendoring.md.

FAQ

Can I still use the go tool?

Yes, this setup was deliberately chosen to be compatible with the go tool. Make sure your workspace appears under

$GOROOT/src/github.com/joe/project/

eg.

mkdir -p $GOROOT/src/github.com/joe/
ln -s my/bazel/workspace $GOROOT/src/github.com/joe/project

and it should work.

Disclaimer

These rules are not supported by Google's Go team.

go_repositories

go_repositories()

Instantiates external dependencies to Go toolchain in a WORKSPACE. All the other workspace rules and build rules assume that this rule is placed in the WORKSPACE.

go_repository

go_repository(name, importpath, remote, commit, tag)

Fetches a remote repository of a Go project, expecting it contains BUILD files. It is an analogy to git_repository but it recognizes importpath redirection of Go.

new_go_repository

new_go_repository(name, importpath, remote, commit, tag)

Fetches a remote repository of a Go project and automatically generates BUILD files in it. It is an analogy to new_git_repository but it recognizes importpath redirection of Go.

go_prefix

go_prefix(prefix)

go_library

go_library(name, srcs, deps, data)

cgo_library

cgo_library(name, srcs, copts, clinkopts, cdeps, deps, data)

NOTE

srcs cannot contain pure-Go files, which do not have import "C". So you need to define another go_library when you build a go package with both cgo-enabled and pure-Go sources.

cgo_library(
    name = "cgo_enabled",
    srcs = ["cgo-enabled.go", "foo.cc", "bar.S", "baz.a"],
)

go_library(
    name = "go_default_library",
    srcs = ["pure-go.go"],
    library = ":cgo_enabled",
)

go_binary

go_binary(name, srcs, deps, data)

go_test

go_test(name, srcs, deps, data)

....

go_proto_library

go_proto_library(name, srcs, deps, has_services)