# Copyright 2018 The Bazel Authors. All rights reserved. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. def _http_archive_impl(ctx): print("http_archive is deprecated. Use http_archive from @bazel_tools//tools/build_defs/repo:http.bzl instead.") overlay = _resolve_overlay(ctx, ctx.attr.overlay) ctx.download_and_extract( url = ctx.attr.urls, sha256 = ctx.attr.sha256, type = ctx.attr.type, stripPrefix = ctx.attr.strip_prefix, ) _apply_overlay(ctx, overlay) http_archive = repository_rule( implementation = _http_archive_impl, doc = """ **NOTE:** `http_archive` is deprecated in favor of the rule of the same name in [@bazel_tools//tools/build_defs/repo:http.bzl]. `http_archive` downloads a project over HTTP(S). It has the same features as the [native http_archive rule], but it also allows you to copy a set of files into the repository after download. This is particularly useful for placing pre-generated build files. **Example** ```starlark load("@bazel_gazelle//:deps.bzl", "http_archive") http_archive( name = "com_github_pkg_errors", urls = ["https://codeload.github.com/pkg/errors/zip/816c9085562cd7ee03e7f8188a1cfd942858cded"], strip_prefix = "errors-816c9085562cd7ee03e7f8188a1cfd942858cded", type = "zip", overlay = { "@my_repo//third_party:com_github_pkg_errors/BUILD.bazel.in" : "BUILD.bazel", }, ) ``` """, attrs = { "urls": attr.string_list( doc = """A list of HTTP(S) URLs where the project can be downloaded. Bazel will attempt to download the first URL; the others are mirrors.""", ), "sha256": attr.string( doc = """The SHA-256 sum of the downloaded archive. When set, Bazel will verify the archive against this sum before extracting it. **CAUTION:** Do not use this with services that prepare source archives on demand, such as codeload.github.com. Any minor change in the server software can cause differences in file order, alignment, and compression that break SHA-256 sums.""", ), "strip_prefix": attr.string( doc = "A directory prefix to strip. See [http_archive.strip_prefix].", ), "type": attr.string( doc = """One of `"zip"`, `"tar.gz"`, `"tgz"`, `"tar.bz2"`, `"tar.xz"`. The file format of the repository archive. This is normally inferred from the downloaded file name.""", ), "overlay": attr.label_keyed_string_dict( allow_files = True, doc = """A set of files to copy into the downloaded repository. The keys in this dictionary are Bazel labels that point to the files to copy. These must be fully qualified labels (i.e., `@repo//pkg:name`) because relative labels are interpreted in the checked out repository, not the repository containing the WORKSPACE file. The values in this dictionary are root-relative paths where the overlay files should be written. It's convenient to store the overlay dictionaries for all repositories in a separate .bzl file. See Gazelle's `manifest.bzl`_ for an example.""", ), }, ) # TODO(jayconrod): add strip_count to remove a number of unnamed # parent directories. # TODO(jayconrod): add sha256_contents to check sha256sum on files extracted # from the archive instead of on the archive itself. def _git_repository_impl(ctx): print("git_repository is deprecated. Use git_repository from @bazel_tools//tools/build_defs/repo:git.bzl instead.") if not ctx.attr.commit and not ctx.attr.tag: fail("either 'commit' or 'tag' must be specified") if ctx.attr.commit and ctx.attr.tag: fail("'commit' and 'tag' may not both be specified") overlay = _resolve_overlay(ctx, ctx.attr.overlay) # TODO(jayconrod): sanitize inputs passed to git. revision = ctx.attr.commit if ctx.attr.commit else ctx.attr.tag _check_execute(ctx, ["git", "clone", "-n", ctx.attr.remote, "."], "failed to clone %s" % ctx.attr.remote) _check_execute(ctx, ["git", "checkout", revision], "failed to checkout revision %s in remote %s" % (revision, ctx.attr.remote)) _apply_overlay(ctx, overlay) git_repository = repository_rule( implementation = _git_repository_impl, doc = """ **NOTE:** `git_repository` is deprecated in favor of the rule of the same name in [@bazel_tools//tools/build_defs/repo:git.bzl]. `git_repository` downloads a project with git. It has the same features as the [native git_repository rule], but it also allows you to copy a set of files into the repository after download. This is particularly useful for placing pre-generated build files. **Example** ```starlark load("@bazel_gazelle//:deps.bzl", "git_repository") git_repository( name = "com_github_pkg_errors", remote = "https://github.com/pkg/errors", commit = "816c9085562cd7ee03e7f8188a1cfd942858cded", overlay = { "@my_repo//third_party:com_github_pkg_errors/BUILD.bazel.in" : "BUILD.bazel", }, ) ``` """, attrs = { "commit": attr.string( doc = "The git commit to check out. Either `commit` or `tag` may be specified.", ), "remote": attr.string( doc = "The remote repository to download.", mandatory = True, ), "tag": attr.string( doc = "The git tag to check out. Either `commit` or `tag` may be specified.", ), "overlay": attr.label_keyed_string_dict( allow_files = True, doc = """A set of files to copy into the downloaded repository. The keys in this dictionary are Bazel labels that point to the files to copy. These must be fully qualified labels (i.e., `@repo//pkg:name`) because relative labels are interpreted in the checked out repository, not the repository containing the WORKSPACE file. The values in this dictionary are root-relative paths where the overlay files should be written. It's convenient to store the overlay dictionaries for all repositories in a separate .bzl file. See Gazelle's `manifest.bzl`_ for an example.""", ), }, ) def _resolve_overlay(ctx, overlay): """Resolve overlay labels to paths. This should be done before downloading the repository, since it may trigger restarts. """ return [(ctx.path(src_label), dst_rel) for src_label, dst_rel in overlay.items()] def _apply_overlay(ctx, overlay): """Copies overlay files into the repository. This should be done after downloading the repository, since it may replace downloaded files. """ # TODO(jayconrod): sanitize destination paths. for src_path, dst_rel in overlay: ctx.template(dst_rel, src_path) def _check_execute(ctx, arguments, message): res = ctx.execute(arguments) if res.return_code != 0: fail(message + "\n" + res.stdout + res.stderr)