Gazelle is a Bazel build file generator for Go projects.
Clone or download
jayconrod walk: don't exclude file names starting with "_" (#398)
Go considers these hidden files and does not build them. The logic for
filtering these should be in the Go extension instead of walk, since
other languages don't have the same rule.

Fixes #395
Latest commit 44ce230 Dec 10, 2018
Permalink
Type Name Latest commit message Commit time
Failed to load latest commit information.
cmd gazelle_binary: create gazelle binaries with custom languages (#365) Dec 7, 2018
config Publishing internal rules and clean up documentation (#360) Nov 2, 2018
flag Publishing internal rules and clean up documentation (#360) Nov 2, 2018
internal gazelle_binary: create gazelle binaries with custom languages (#365) Dec 7, 2018
label Publishing internal rules and clean up documentation (#360) Nov 2, 2018
language walk: don't exclude file names starting with "_" (#398) Dec 10, 2018
merger gazelle_binary: create gazelle binaries with custom languages (#365) Dec 7, 2018
pathtools Publishing internal rules and clean up documentation (#360) Nov 2, 2018
repo Publishing internal rules and clean up documentation (#360) Nov 2, 2018
resolve Publishing internal rules and clean up documentation (#360) Nov 2, 2018
rule Publishing internal rules and clean up documentation (#360) Nov 2, 2018
testtools Publishing internal rules and clean up documentation (#360) Nov 2, 2018
third_party Run buildifier on the repository (#280) Aug 3, 2018
vendor cmd/autogazelle: bazel wrapper for automatically updating build files ( Oct 9, 2018
walk walk: don't exclude file names starting with "_" (#398) Dec 10, 2018
.bazelrc Move tools/bazel.rc to .bazelrc (#357) Nov 1, 2018
.gitignore Create and run import script Nov 3, 2017
.travis.yml Update bazel used in CI; remove deprecated --batch (#281) Aug 3, 2018
AUTHORS Add legal files Nov 13, 2017
BUILD.bazel Squash internal and external go_tests (#172) Apr 2, 2018
CODEOWNERS Add test and review infrastructure files (#1) Dec 5, 2017
CONTRIBUTING.md Add legal files Nov 13, 2017
CONTRIBUTORS Add legal files Nov 13, 2017
Design.rst Gazelle design document (#97) Feb 7, 2018
LICENSE Rename LICENSE.txt to LICENSE Nov 13, 2017
README.rst gazelle_binary: create gazelle binaries with custom languages (#365) Dec 7, 2018
WORKSPACE Update rules_go dependency to 0.16.2 (#379) Nov 21, 2018
def.bzl gazelle_binary: create gazelle binaries with custom languages (#365) Dec 7, 2018
deps.bzl Explicitly export symbols that need it, reformat files with Buildifier ( Nov 27, 2018
extend.rst gazelle_binary: create gazelle binaries with custom languages (#365) Dec 7, 2018
go.mod cmd/autogazelle: bazel wrapper for automatically updating build files ( Oct 9, 2018
go.sum cmd/autogazelle: bazel wrapper for automatically updating build files ( Oct 9, 2018
repository.rst Deprecate git_repository and http_archive (#356) Oct 30, 2018

README.rst

Gazelle build file generator

Gazelle is a build file generator for Go projects. It can create new BUILD.bazel files for a project that follows "go build" conventions, and it can update existing build files to include new sources, dependencies, and options. Gazelle may be run by Bazel using the gazelle rule, or it can be run as a command line tool. Gazelle can also be run in an external repository as part of the go_repository rule. Gazelle may be extended to support new languages and custom rule sets.

Gazelle is under active development. Its interface and the rules it generates may change. Gazelle is not an official Google product.

See also:

Setup

Running Gazelle with Bazel

To use Gazelle in a new project, add the bazel_gazelle repository and its dependencies to your WORKSPACE file and call gazelle_dependencies. It should look like this:

load("@bazel_tools//tools/build_defs/repo:http.bzl", "http_archive")
http_archive(
    name = "io_bazel_rules_go",
    urls = ["https://github.com/bazelbuild/rules_go/releases/download/0.16.3/rules_go-0.16.3.tar.gz"],
    sha256 = "b7a62250a3a73277ade0ce306d22f122365b513f5402222403e507f2f997d421",
)
http_archive(
    name = "bazel_gazelle",
    urls = ["https://github.com/bazelbuild/bazel-gazelle/releases/download/0.15.0/bazel-gazelle-0.15.0.tar.gz"],
    sha256 = "6e875ab4b6bf64a38c352887760f21203ab054676d9c1b274963907e0768740d",
)
load("@io_bazel_rules_go//go:def.bzl", "go_rules_dependencies", "go_register_toolchains")
go_rules_dependencies()
go_register_toolchains()
load("@bazel_gazelle//:deps.bzl", "gazelle_dependencies")
gazelle_dependencies()

Add the code below to the BUILD or BUILD.bazel file in the root directory of your repository. Replace the string after prefix with the portion of your import path that corresponds to your repository.

load("@bazel_gazelle//:def.bzl", "gazelle")

# gazelle:prefix github.com/example/project
gazelle(name = "gazelle")

After adding this code, you can run Gazelle with Bazel.

$ bazel run //:gazelle

This will generate new BUILD.bazel files for your project. You can run the same command in the future to update existing BUILD.bazel files to include new source files or options.

You can pass additional arguments to Gazelle after a -- argument. This can be used to run alternate commands like update-repos that the gazelle rule cannot run directly.

$ bazel run //:gazelle -- update-repos -from_file=go.mod

Running Gazelle with Go

If you have a Go SDK installed, you can install Gazelle with the command below:

go get -u github.com/bazelbuild/bazel-gazelle/cmd/gazelle

Make sure to re-run this command to upgrade Gazelle whenever you upgrade rules_go in your repository.

To generate BUILD.bazel files in a new project, run the command below, replacing the prefix with the portion of your import path that corresponds to your repository.

gazelle -go_prefix github.com/example/project

Most of Gazelle's command-line arguments can be expressed as special comments in build files. See Directives below. You may want to copy this line into your root build files to avoid having to type -go_prefix every time.

# gazelle:prefix github.com/example/project

Compatibility

Gazelle generates build files that use features in newer versions of rules_go. Newer versions of Gazelle may generate build files that work with older versions of rules_go, but check the table below to ensure you're using a compatible version.

Gazelle version Minimum rules_go version Maximum rules_go version
0.8 0.8.0 n/a
0.9 0.9.0 n/a
0.10.0 0.9.0 0.11.0
0.11.0 0.11.0 n/a
0.12.0 0.11.0 n/a
0.13.0 0.13.0 n/a
0.14.0 0.13.0 n/a
0.15.0 0.13.0 n/a

Usage

Command line

gazelle <command> [flags...] [package-dirs...]

The first argument to Gazelle may be one of the commands below. If no command is specified, update is assumed. The remaining arguments are specific to each command and are documented below.

update
Scans sources files, then generates and updates build files.
fix
Same as the update command, but it also fixes deprecated usage of rules.
update-repos
Adds and updates repository rules in the WORKSPACE file.

Bazel rule

Gazelle may be run via a rule. See Running Gazelle with Bazel for setup instructions. This rule builds Gazelle and generates a wrapper script that executes Gazelle with baked-in set of arguments. You can run this script with bazel run, or you can copy it into your workspace and run it directly.

The following attributes are available on the gazelle rule.

Name Type Default value
gazelle label @bazel_gazelle//cmd/gazelle
The gazelle_binary rule that builds Gazelle. You can substitute a modified version of Gazelle with this. See Extending Gazelle.
external string external
The method for resolving unknown imports to Bazel dependencies. May be external or vendored. See Dependency resolution.
build_tags string_list []
The last of Go build tags that Gazelle should consider to always be true.
prefix string ""

The import path that corresponds to the repository root directory.

Note: It's usually better to write a directive like # gazelle:prefix example.com/repo in your build file instead of setting this attribute.

extra_args string_list []
A list of extra command line arguments passed to Gazelle.
command string update
The Gazelle command to use. May be fix or update. To run a different command, e.g., update-repos, you'll need to copy the invoke the generated wrapper script directly with explicit arguments.

fix and update

The update command is the most common way of running Gazelle. Gazelle scans sources in directories throughout the repository, then creates and updates build files.

The fix command does everything update does, but it also fixes deprecated usage of rules, analogous to go fix. For example, cgo_library will be consolidated with go_library. This command may delete or rename rules, so it's not on by default. See Fix command transformations for details.

Both commands accept a list of directories to process as positional arguments. If no directories are specified, Gazelle will process the current directory. Subdirectories will be processed recursively.

The following flags are accepted:

Name Default value
-build_file_name file1,file2,... BUILD.bazel,BUILD
Comma-separated list of file names. Gazelle recognizes these files as Bazel build files. New files will use the first name in this list. Use this if your project contains non-Bazel files named BUILD (or build on case-insensitive file systems).
-build_tags tag1,tag2  

List of Go build tags Gazelle will consider to be true. Gazelle applies constraints when generating Go rules. It assumes certain tags are true on certain platforms (for example, amd64,linux). It assumes all Go release tags are true (for example, go1.8). It considers other tags to be false (for example, ignore). This flag overrides that behavior.

Bazel may still filter sources with these tags. Use bazel build --features gotags=foo,bar to set tags at build time.

-exclude path  

Prevents Gazelle from processing a file or directory. If the path refers to a source file, Gazelle won't include it in any rules. If the path refers to a directory, Gazelle won't recurse into it.

This option may be repeated. Paths must be slash-separated, relative to the repository root. This is equivalent to the # gazelle:exclude path directive.

-external external|vendored external
Determines how Gazelle resolves import paths that cannot be resolve in the current repository. May be external or vendored. See Dependency resolution.
-go_prefix example.com/repo  

A prefix of import paths for libraries in the repository that corresponds to the repository root. Gazelle infers this from the go_prefix rule in the root BUILD.bazel file, if it exists. If not, this option is mandatory.

This prefix is used to determine whether an import path refers to a library in the current repository or an external dependency.

-known_import example.com  

Skips import path resolution for a known domain. May be repeated.

When Gazelle resolves an import path to an external dependency, it attempts to discover the remote repository root over HTTP. Gazelle skips this discovery step for a few well-known domains with predictable structure, like golang.org and github.com. This flag specifies additional domains to skip, which is useful in situations where the lookup would fail for some reason.

-mode fix|print|diff fix

Method for emitting merged build files.

In fix mode, Gazelle writes generated and merged files to disk. In print mode, it prints them to stdout. In diff mode, it prints a unified diff.

-proto default|package|legacy|disable|disable_global default
Determines how Gazelle should generate rules for .proto files. See details in Directives below.
-proto_group group ""
Determines the proto option Gazelle uses to group .proto files into rules when in package mode. See details in Directives below.
-repo_root dir  

The root directory of the repository. Gazelle normally infers this to be the directory containing the WORKSPACE file.

Gazelle will not process packages outside this directory.

update-repos

The update-repos command updates repository rules in the WORKSPACE file. It can be used to add new repository rules or update existing rules to the latest version. It can also import repository rules from a go.mod file or a Gopkg.lock file.

# Add or update a repository by import path
$ gazelle update-repos example.com/new/repo

# Import repositories from go.mod
$ gazelle update-repos -from_file=go.mod
Note:

update-repos is not directly supported by the gazelle rule. You can run it through the gazelle rule by passing extra arguments after --. For example:

$ bazel run //:gazelle -- update-repos example.com/new/repo

The following flags are accepted:

Name Default value
-from_file lock-file  

Import repositories from a file as go_repository rules. These rules will be added to the bottom of the WORKSPACE file or merged with existing rules.

The lock file format is inferred from the file name. go.mod and Gopkg.lock (the dep lock format) are both supported.

-repo_root dir  

The root directory of the repository. Gazelle normally infers this to be the directory containing the WORKSPACE file.

Gazelle will not process packages outside this directory.

Directives

Gazelle can be configured with directives, which are written as top-level comments in build files. Most options that can be set on the command line can also be set using directives. Some options can only be set with directives.

Directive comments have the form # gazelle:key value. For example:

load("@io_bazel_rules_go//go:def.bzl", "go_library")

# gazelle:prefix github.com/example/project
# gazelle:build_file_name BUILD,BUILD.bazel

go_library(
    name = "go_default_library",
    srcs = ["example.go"],
    importpath = "github.com/example/project",
    visibility = ["//visibility:public"],
)

Directives apply in the directory where they are set and in subdirectories. This means, for example, if you set # gazelle:prefix in the build file in your project's root directory, it affects your whole project. If you set it in a subdirectory, it only affects rules in that subtree.

The following directives are recognized:

Directive Default value
# gazelle:build_file_name names BUILD.bazel,BUILD
Comma-separated list of file names. Gazelle recognizes these files as Bazel build files. New files will use the first name in this list. Use this if your project contains non-Bazel files named BUILD (or build on case-insensitive file systems).
# gazelle:build_tags foo,bar none

List of Go build tags Gazelle will consider to be true. Gazelle applies constraints when generating Go rules. It assumes certain tags are true on certain platforms (for example, amd64,linux). It assumes all Go release tags are true (for example, go1.8). It considers other tags to be false (for example, ignore). This flag overrides that behavior.

Bazel may still filter sources with these tags. Use bazel build --features gotags=foo,bar to set tags at build time.

# gazelle:exclude path n/a
Prevents Gazelle from processing a file or directory. If the path refers to a source file, Gazelle won't include it in any rules. If the path refers to a directory, Gazelle won't recurse into it. The path may refer to something withinin a subdirectory, for example, a testdata directory somewhere in a vendor tree. This directive may be repeated to exclude multiple paths, one per line.
# gazelle:follow path n/a

Instructs Gazelle to follow a symbolic link to a directory within the repository. Normally, Gazelle does not follow symbolic links unless they point outside of the repository root.

Care must be taken to avoid visiting a directory more than once. The # gazelle:exclude directive may be used to prevent Gazelle from recursing into a directory.

# gazelle:ignore n/a
Prevents Gazelle from modifying the build file. Gazelle will still read rules in the build file and may modify build files in subdirectories.
# gazelle:importmap_prefix path See below

A prefix for importmap attributes in library rules. Gazelle will set an importmap on a go_library or go_proto_library by concatenating this with the relative path from the directory where the prefix is set to the library. For example, if importmap_prefix is set to "x/example.com/repo" in the build file //foo/bar:BUILD.bazel, then a library in foo/bar/baz will have the importmap of "x/example.com/repo/baz".

importmap is not set when it matches importpath.

As a special case, when Gazelle enters a directory named vendor, it sets importmap_prefix to a string based on the repository name and the location of the vendor directory. If you wish to override this, you'll need to set importmap_prefix explicitly in the vendor directory.

# gazelle:prefix path n/a

A prefix for importpath attributes on library rules. Gazelle will set an importpath on a go_library or go_proto_library by concatenating this with the relative path from the directory where the prefix is set to the library. Most commonly, prefix is set to the name of a repository in the root directory of a repository. For example, in this repository, prefix is set in //:BUILD.bazel to github.com/bazelbuild/bazel-gazelle. The go_library in //cmd/gazelle is assigned the importpath "github.com/bazelbuild/bazel-gazelle/cmd/gazelle".

As a special case, when Gazelle enters a directory named vendor, it sets prefix to the empty string. This automatically gives vendored libraries an intuitive importpath.

# gazelle:proto mode default

Tells Gazelle how to generate rules for .proto files. Valid values are:

  • default: proto_library, go_proto_library, and go_library rules are generated using @io_bazel_rules_go//proto:def.bzl. Only one of each rule may be generated per directory. This is the default mode.
  • package: multiple proto_library and go_proto_library rules may be generated in the same directory. .proto files are grouped into rules based on their package name or another option (see proto_group).
  • legacy: filegroup rules are generated for use by @io_bazel_rules_go//proto:go_proto_library.bzl. go_proto_library rules must be written by hand. Gazelle will run in this mode automatically if go_proto_library.bzl is loaded to avoid disrupting existing projects, but this can be overridden with a directive.
  • disable: .proto files are ignored. Gazelle will run in this mode automatically if go_proto_library is loaded from any other source, but this can be overridden with a directive.
  • disable_global: like disable mode, but also prevents Gazelle from using any special cases in dependency resolution for Well Known Types and Google APIs. Useful for avoiding build-time dependencies on protoc.

This directive applies to the current directory and subdirectories. As a special case, when Gazelle enters a directory named vendor, if the proto mode isn't set explicitly in a parent directory or on the command line, Gazelle will run in disable mode. Additionally, if the file @io_bazel_rules_go//proto:go_proto_library.bzl is loaded, Gazelle will run in legacy mode.

# gazelle:proto_group option ""

This directive is only effective in package mode (see above).

Specifies an option that Gazelle can use to group .proto files into rules. For example, when set to go_package, .proto files with the same option go_package will be grouped together.

When this directive is set to the empty string, Gazelle will group packages by their proto package statement.

Rule names are generated based on the last run of identifier characters in the package name. For example, if the package is "foo/bar/baz", the proto_library rule will be named baz_proto.

# gazelle:resolve ... n/a

Specifies an explicit mapping from an import string to a label for Dependency resolution. The format for a resolve directive is:

# gazelle:resolve source-lang import-lang import-string label

  • source-lang is the language of the source code being imported.
  • import-lang is the language importing the library. This is usually the same as source-lang but may differ with generated code. For example, when resolving dependencies for a go_proto_library, source-lang would be "proto" and import-lang would be "go". import-lang may be omitted if it is the same as source-lang.
  • import-string is the string used in source code to import a library.
  • label is the Bazel label that Gazelle should write in deps.

For example:

# gazelle:resolve go example.com/foo //foo:go_default_library
# gazelle:resolve proto go foo/foo.proto //foo:foo_go_proto

Keep comments

In addition to directives, Gazelle supports # keep comments that protect parts of build files from being modified. # keep may be written before a rule, before an attribute, or after a string within a list.

Example

Suppose you have a library that includes a generated .go file. Gazelle won't know what imports to resolve, so you may need to add dependencies manually with # keep comments.

load("@io_bazel_rules_go//go:def.bzl", "go_library")
load("@com_github_example_gen//:gen.bzl", "gen_go_file")

gen_go_file(
    name = "magic",
    srcs = ["magic.go.in"],
    outs = ["magic.go"],
)

go_library(
    name = "go_default_library",
    srcs = ["magic.go"],
    visibility = ["//visibility:public"],
    deps = [
        "@com_github_example_gen//:go_default_library",  # keep
    ],
)

Dependency resolution

One of Gazelle's most important jobs is resolving library import strings (like import "golang.org/x/sys/unix") to Bazel labels (like @org_golang_x_sys//unix:go_default_library). Gazelle follows the rules below to resolve dependencies:

  1. If the import to be resolved is part of a standard library, no explicit dependency is written. For example, in Go, you don't need to declare that you depend on "fmt".
  2. If a # gazelle:resolve directive matches the import to be resolved, the label at the end of the directive will be used.
  3. If proto rule generation is enabled, special rules will be used when importing certain libraries. These rules may be disabled by adding # gazelle:proto disable_global to a build file (this will affect subdirectories, too) or by passing -proto disable_global on the command line.
    1. Imports of Well Known Types are mapped to rules in @io_bazel_rules_go//proto/wkt.
    2. Imports of Google APIs are mapped to @go_googleapis.
    3. Imports of github.com/golang/protobuf/ptypes, descriptor, and jsonpb are mapped to special rules in @com_github_golang_protobuf. See Avoiding conflicts with proto rules.
  4. If the import to be resolved is provided by a library in the current repository, the import will be resolved to that library. Gazelle builds an index of library rules in the current repository before starting dependency resolution, and this is how most dependencies are resolved.
    1. For Go, the match is based on the importpath attribute.
    2. For proto, the match is based on the srcs attribute.
  5. If a package is imported that has the current go_prefix as a prefix, Gazelle generates a label following a convention. For example, if the build file in //src set the prefix with # gazelle:prefix example.com/repo/foo, and you import the library "example.com/repo/foo/bar, the dependency will be "//src/foo/bar:go_default_library".
  6. Otherwise, Gazelle will use the current external mode to resolve the dependency.
    1. In external mode (the default), Gazelle will transform the import string into an external repository label. For example, "golang.org/x/sys/unix" would be resolved to "@org_golang_x_sys//unix:go_default_library". Gazelle does not confirm whether the external repository is actually declared in WORKSPACE, but if there is a go_repository in WORKSPACE with a matching importpath, Gazelle will use its name. Gazelle does not index rules in external repositories, so it's possible the resolved dependency does not exist.
    2. In vendored mode, Gazelle will transform the import string into a label in the vendor directory. For example, "golang.org/x/sys/unix" would be resolved to "//vendor/golang.org/x/sys/unix:go_default_library". This mode is usually not necessary, since vendored libraries will be indexed and resolved using rule 4.

Fix command transformations

Gazelle will generate and update build files when invoked with either gazelle update or gazelle fix (update is the default). Both commands perform several transformations to fix deprecated usage of the Go rules. update performs a safe set of tranformations, while fix performs some additional transformations that may delete or rename rules.

The following transformations are performed:

Migrate library to embed (fix and update): Gazelle replaces library attributes with embed attributes.

Migrate gRPC compilers (fix and update): Gazelle converts go_grpc_library rules to go_proto_library rules with compilers = ["@io_bazel_rules_go//proto:go_grpc"].

Flatten srcs (fix and update): Gazelle converts srcs attributes that use OS and architecture-specific select expressions to flat lists. rules_go filters these sources anyway.

Squash cgo libraries (fix only): Gazelle will remove cgo_library rules named cgo_default_library and merge their attributes with a go_library rule in the same package named go_default_library. If no such go_library rule exists, a new one will be created. Other cgo_library rules will not be removed.

Squash external tests (fix only): Gazelle will squash go_test rules named go_default_xtest into go_default_test. Earlier versions of rules_go required internal and external tests to be built separately, but this is no longer needed.

Remove legacy protos (fix only): Gazelle will remove usage of go_proto_library rules loaded from @io_bazel_rules_go//proto:go_proto_library.bzl and filegroup rules named go_default_library_protos. Newly generated proto rules will take their place. Since filegroup isn't needed anymore and go_proto_library has different attributes and was always written by hand, Gazelle will not attempt to merge anything from these rules with the newly generated rules.

This transformation is only applied in the default proto mode. Since Gazelle will run in legacy proto mode if go_proto_library.bzl is loaded, this transformation is not usually applied. You can set the proto mode explicitly using the directive # gazelle:proto default.

Update loads of gazelle rule (fix and update): Gazelle will remove loads of gazelle from @io_bazel_rules_go//go:def.bzl. It will automatically add a load from @bazel_gazelle//:def.bzl if gazelle is not loaded from another location.