Java tutorial
// Copyright 2016 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. package com.google.devtools.build.lib.rules.proto; import static com.google.devtools.build.lib.packages.Attribute.ConfigurationTransition.HOST; import static com.google.devtools.build.lib.packages.Attribute.attr; import static com.google.devtools.build.lib.packages.BuildType.LABEL_LIST; import com.google.common.annotations.VisibleForTesting; import com.google.common.base.Joiner; import com.google.common.base.Predicate; import com.google.common.base.Predicates; import com.google.common.collect.ImmutableSet; import com.google.common.collect.Iterables; import com.google.devtools.build.lib.actions.Artifact; import com.google.devtools.build.lib.analysis.RuleContext; import com.google.devtools.build.lib.cmdline.Label; import com.google.devtools.build.lib.packages.Attribute; import com.google.devtools.build.lib.vfs.PathFragment; import java.util.ArrayList; import java.util.List; /** * A blacklist of proto source files. * * <p>There are cases where we need to identify proto files that we should not create generated * files for. For example, we should not create generated code for google/protobuf/any.proto, which * is already baked into the language support libraries. This class provides us with the ability * to identify these proto files and avoid linking in their associated generated files. */ public class ProtoSourceFileBlacklist { private static final PathFragment BAZEL_TOOLS_PREFIX = new PathFragment("external/bazel_tools/"); private final RuleContext ruleContext; private final ImmutableSet<PathFragment> blacklistProtoFilePaths; private final Predicate<Artifact> isBlacklistProto = new Predicate<Artifact>() { @Override public boolean apply(Artifact protoFile) { return isBlacklisted(protoFile); } }; /** * Creates a proto source file blacklist. * * @param ruleContext the proto rule context. * @param blacklistProtoFiles a list of blacklisted .proto files. The list will be iterated. * protos. */ public ProtoSourceFileBlacklist(RuleContext ruleContext, Iterable<Artifact> blacklistProtoFiles) { this.ruleContext = ruleContext; ImmutableSet.Builder<PathFragment> blacklistProtoFilePathsBuilder = new ImmutableSet.Builder<>(); for (Artifact blacklistProtoFile : blacklistProtoFiles) { PathFragment execPath = blacklistProtoFile.getExecPath(); // For blacklisted protos bundled with the Bazel tools repository, their exec paths start // with external/bazel_tools/. This prefix needs to be removed first, because the protos in // user repositories will not have that prefix. if (execPath.startsWith(BAZEL_TOOLS_PREFIX)) { blacklistProtoFilePathsBuilder.add(execPath.relativeTo(BAZEL_TOOLS_PREFIX)); } else { blacklistProtoFilePathsBuilder.add(execPath); } } blacklistProtoFilePaths = blacklistProtoFilePathsBuilder.build(); } /** * Filters the blacklisted protos from the given protos. */ public Iterable<Artifact> filter(Iterable<Artifact> protoFiles) { return ImmutableSet.copyOf(Iterables.filter(protoFiles, Predicates.not(isBlacklistProto))); } /** * Checks the proto sources for mixing blacklisted and non-blacklisted protos in one single * proto_library rule. Registers an attribute error if proto mixing is detected. * * @param protoFiles the protos to filter. * @param topLevelProtoRuleName the name of the top-level rule that generates the protos. * @return whether the proto sources are clean without mixing. */ public boolean checkSrcs(Iterable<Artifact> protoFiles, String topLevelProtoRuleName) { List<Artifact> blacklisted = new ArrayList<>(); List<Artifact> nonBlacklisted = new ArrayList<>(); for (Artifact protoFile : protoFiles) { if (isBlacklisted(protoFile)) { blacklisted.add(protoFile); } else { nonBlacklisted.add(protoFile); } } if (!nonBlacklisted.isEmpty() && !blacklisted.isEmpty()) { ruleContext.attributeError("srcs", createBlacklistedProtosMixError(Artifact.toRootRelativePaths(blacklisted), Artifact.toRootRelativePaths(nonBlacklisted), ruleContext.getLabel().toString(), topLevelProtoRuleName)); } return blacklisted.isEmpty(); } /** * Returns whether the given proto file is blacklisted. */ public boolean isBlacklisted(Artifact protoFile) { return blacklistProtoFilePaths.contains(protoFile.getExecPath()); } /** * Returns an attribute for the implicit dependency on blacklist proto filegroups. * @param attributeName the name of the attribute. * @param blacklistFileGroups a list of labels pointin to the filegroups containing blacklisted * protos. */ public static Attribute.Builder<List<Label>> blacklistFilegroupAttribute(String attributeName, List<Label> blacklistFileGroups) { return attr(attributeName, LABEL_LIST).cfg(HOST).value(blacklistFileGroups); } @VisibleForTesting public static String createBlacklistedProtosMixError(Iterable<String> blacklisted, Iterable<String> nonBlacklisted, String protoLibraryRuleLabel, String topLevelProtoRuleName) { return String.format( "The 'srcs' attribute of '%s' contains protos for which '%s' " + "shouldn't generate code (%s), in addition to protos for which it should (%s).\n" + "Separate '%1$s' into 2 proto_library rules.", protoLibraryRuleLabel, topLevelProtoRuleName, Joiner.on(", ").join(blacklisted), Joiner.on(", ").join(nonBlacklisted)); } }