// Copyright 2014 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.analysis;
import com.google.common.base.Joiner;
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableMap;
import com.google.common.collect.ImmutableSet;
import com.google.common.collect.Iterables;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.devtools.build.lib.actions.Artifact;
import com.google.devtools.build.lib.analysis.RuleConfiguredTarget.Mode;
import com.google.devtools.build.lib.cmdline.Label;
import com.google.devtools.build.lib.cmdline.LabelSyntaxException;
import com.google.devtools.build.lib.packages.BuildType;
import com.google.devtools.build.lib.packages.OutputFile;
import com.google.devtools.build.lib.rules.AliasProvider;
import com.google.devtools.build.lib.vfs.PathFragment;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;
/**
* Expands $(location) tags inside target attributes.
* You can specify something like this in the BUILD file:
*
* somerule(name='some name',
* someopt = [ '$(location //mypackage:myhelper)' ],
* ...)
*
* and location will be substituted with //mypackage:myhelper executable output.
* Note that //mypackage:myhelper should have just one output.
*/
public class LocationExpander {
/**
* List of options to tweak the LocationExpander.
*/
public static enum Options {
/** output the execPath instead of the relative path */
EXEC_PATHS,
/** Allow to take label from the data attribute */
ALLOW_DATA,
}
private static final int MAX_PATHS_SHOWN = 5;
private static final String LOCATION = "$(location";
private final RuleContext ruleContext;
private final ImmutableSet<Options> options;
/**
* This is a Map, not a Multimap, because we need to distinguish between the cases of "empty
* value" and "absent key."
*/
private Map<Label, Collection<Artifact>> locationMap;
private ImmutableMap<Label, ImmutableCollection<Artifact>> labelMap;
/**
* Creates location expander helper bound to specific target and with default location map.
*
* @param ruleContext BUILD rule
* @param labelMap A mapping of labels to build artifacts.
* @param allowDataAttributeEntriesInLabel set to true if the <code>data</code> attribute should
* be used too.
*/
public LocationExpander(
RuleContext ruleContext, ImmutableMap<Label, ImmutableCollection<Artifact>> labelMap,
boolean allowDataAttributeEntriesInLabel) {
this.ruleContext = ruleContext;
ImmutableSet.Builder<Options> builder = ImmutableSet.builder();
builder.add(Options.EXEC_PATHS);
if (allowDataAttributeEntriesInLabel) {
builder.add(Options.ALLOW_DATA);
}
this.options = builder.build();
this.labelMap = labelMap;
}
/**
* Creates location expander helper bound to specific target.
*
* @param ruleContext the BUILD rule's context
* @param options the list of options, see {@link Options}.
*/
public LocationExpander(RuleContext ruleContext, ImmutableSet<Options> options) {
this.ruleContext = ruleContext;
this.options = options;
}
/**
* Creates location expander helper bound to specific target.
*
* @param ruleContext the BUILD rule's context
* @param options the list of options, see {@link Options}.
*/
public LocationExpander(RuleContext ruleContext, Options... options) {
this.ruleContext = ruleContext;
this.options = ImmutableSet.copyOf(options);
}
private Map<Label, Collection<Artifact>> getLocationMap() {
if (locationMap == null) {
locationMap = buildLocationMap(ruleContext, labelMap, options.contains(Options.ALLOW_DATA));
}
return locationMap;
}
public String expand(String input) {
return expand(input, new RuleErrorReporter());
}
/**
* Expands attribute's location and locations tags based on the target and
* location map.
*
* @param attrName name of the attribute
* @param attrValue initial value of the attribute
* @return attribute value with expanded location tags or original value in
* case of errors
*/
public String expandAttribute(String attrName, String attrValue) {
return expand(attrValue, new AttributeErrorReporter(attrName));
}
private String expand(String value, ErrorReporter reporter) {
int restart = 0;
int attrLength = value.length();
StringBuilder result = new StringBuilder(value.length());
while (true) {
// (1) find '$(location ' or '$(locations '
String message = "$(location)";
boolean multiple = false;
int start = value.indexOf(LOCATION, restart);
int scannedLength = LOCATION.length();
if (start == -1 || start + scannedLength == attrLength) {
result.append(value.substring(restart));
break;
}
if (value.charAt(start + scannedLength) == 's') {
scannedLength++;
if (start + scannedLength == attrLength) {
result.append(value.substring(restart));
break;
}
message = "$(locations)";
multiple = true;
}
if (value.charAt(start + scannedLength) != ' ') {
result.append(value, restart, start + scannedLength);
restart = start + scannedLength;
continue;
}
scannedLength++;
int end = value.indexOf(')', start + scannedLength);
if (end == -1) {
reporter.report(ruleContext, "unterminated " + message + " expression");
return value;
}
message = String.format(" in %s expression", message);
// (2) parse label
String labelText = value.substring(start + scannedLength, end).trim();
Label label = parseLabel(labelText, message, reporter);
if (label == null) {
// Error was already reported in parseLabel()
return value;
}
// (3) expand label; stop this operation if there is an error
try {
Collection<String> paths = resolveLabel(label, message, multiple);
result.append(value, restart, start);
if (multiple) {
Joiner.on(' ').appendTo(result, paths);
} else {
result.append(Iterables.getOnlyElement(paths));
}
} catch (IllegalStateException ise) {
reporter.report(ruleContext, ise.getMessage());
return value;
}
restart = end + 1;
}
return result.toString();
}
private Label parseLabel(String labelText, String message, ErrorReporter reporter) {
try {
return ruleContext.getLabel().getRelative(labelText);
} catch (LabelSyntaxException e) {
reporter.report(ruleContext, String.format("invalid label%s: %s", message, e.getMessage()));
return null;
}
}
/**
* Returns all possible target location(s) of the given label
* @param message Original message, for error reporting purposes only
* @param hasMultipleTargets Describes whether the label has multiple target locations
* @return The collection of all path strings
*/
private Collection<String> resolveLabel(
Label unresolved, String message, boolean hasMultipleTargets) throws IllegalStateException {
// replace with singleton artifact, iff unique.
Collection<Artifact> artifacts = getLocationMap().get(unresolved);
if (artifacts == null) {
throw new IllegalStateException(
"label '" + unresolved + "'" + message + " is not a declared prerequisite of this rule");
}
Set<String> paths = getPaths(artifacts, options.contains(Options.EXEC_PATHS));
if (paths.isEmpty()) {
throw new IllegalStateException(
"label '" + unresolved + "'" + message + " expression expands to no files");
}
if (!hasMultipleTargets && paths.size() > 1) {
throw new IllegalStateException(
String.format(
"label '%s'%s expands to more than one file, "
+ "please use $(locations %s) instead. Files (at most %d shown) are: %s",
unresolved,
message,
unresolved,
MAX_PATHS_SHOWN,
Iterables.limit(paths, MAX_PATHS_SHOWN)));
}
return paths;
}
/**
* Extracts all possible target locations from target specification.
*
* @param ruleContext BUILD target object
* @param labelMap map of labels to build artifacts
* @return map of all possible target locations
*/
private static Map<Label, Collection<Artifact>> buildLocationMap(
RuleContext ruleContext,
Map<Label, ? extends Collection<Artifact>> labelMap,
boolean allowDataAttributeEntriesInLabel) {
Map<Label, Collection<Artifact>> locationMap = Maps.newHashMap();
if (labelMap != null) {
for (Map.Entry<Label, ? extends Collection<Artifact>> entry : labelMap.entrySet()) {
mapGet(locationMap, entry.getKey()).addAll(entry.getValue());
}
}
// Add all destination locations.
for (OutputFile out : ruleContext.getRule().getOutputFiles()) {
mapGet(locationMap, out.getLabel()).add(ruleContext.createOutputArtifact(out));
}
if (ruleContext.getRule().isAttrDefined("srcs", BuildType.LABEL_LIST)) {
for (TransitiveInfoCollection src : ruleContext
.getPrerequisitesIf("srcs", Mode.TARGET, FileProvider.class)) {
Iterables.addAll(mapGet(locationMap, AliasProvider.getDependencyLabel(src)),
src.getProvider(FileProvider.class).getFilesToBuild());
}
}
// Add all locations associated with dependencies and tools
List<TransitiveInfoCollection> depsDataAndTools = new ArrayList<>();
if (ruleContext.getRule().isAttrDefined("deps", BuildType.LABEL_LIST)) {
Iterables.addAll(depsDataAndTools,
ruleContext.getPrerequisitesIf("deps", Mode.DONT_CHECK, FilesToRunProvider.class));
}
if (allowDataAttributeEntriesInLabel
&& ruleContext.getRule().isAttrDefined("data", BuildType.LABEL_LIST)) {
Iterables.addAll(depsDataAndTools,
ruleContext.getPrerequisitesIf("data", Mode.DATA, FilesToRunProvider.class));
}
if (ruleContext.getRule().isAttrDefined("tools", BuildType.LABEL_LIST)) {
Iterables.addAll(depsDataAndTools,
ruleContext.getPrerequisitesIf("tools", Mode.HOST, FilesToRunProvider.class));
}
for (TransitiveInfoCollection dep : depsDataAndTools) {
Label label = AliasProvider.getDependencyLabel(dep);
FilesToRunProvider filesToRun = dep.getProvider(FilesToRunProvider.class);
Artifact executableArtifact = filesToRun.getExecutable();
// If the label has an executable artifact add that to the multimaps.
if (executableArtifact != null) {
mapGet(locationMap, label).add(executableArtifact);
} else {
mapGet(locationMap, label).addAll(filesToRun.getFilesToRun());
}
}
return locationMap;
}
/**
* Extracts list of all executables associated with given collection of label
* artifacts.
*
* @param artifacts to get the paths of
* @param takeExecPath if false, the root relative path will be taken
* @return all associated executable paths
*/
private static Set<String> getPaths(Collection<Artifact> artifacts, boolean takeExecPath) {
TreeSet<String> paths = Sets.newTreeSet();
for (Artifact artifact : artifacts) {
PathFragment execPath =
takeExecPath ? artifact.getExecPath() : artifact.getRootRelativePath();
if (execPath != null) { // omit middlemen etc
paths.add(execPath.getCallablePathString());
}
}
return paths;
}
/**
* Returns the value in the specified map corresponding to 'key', creating and
* inserting an empty container if absent. We use Map not Multimap because
* we need to distinguish the cases of "empty value" and "absent key".
*
* @return the value in the specified map corresponding to 'key'
*/
private static <K, V> Collection<V> mapGet(Map<K, Collection<V>> map, K key) {
Collection<V> values = map.get(key);
if (values == null) {
// We use sets not lists, because it's conceivable that the same label
// could appear twice, in "srcs" and "deps".
values = Sets.newHashSet();
map.put(key, values);
}
return values;
}
private static interface ErrorReporter {
void report(RuleContext ctx, String error);
}
private static final class AttributeErrorReporter implements ErrorReporter {
private final String attrName;
public AttributeErrorReporter(String attrName) {
this.attrName = attrName;
}
@Override
public void report(RuleContext ctx, String error) {
ctx.attributeError(attrName, error);
}
}
private static final class RuleErrorReporter implements ErrorReporter {
@Override
public void report(RuleContext ctx, String error) {
ctx.ruleError(error);
}
}
}