@Override
public Iterable<BuildTarget> findDepsForTargetFromConstructorArgs(
BuildTarget buildTarget, CellPathResolver cellRoots, Arg constructorArg) {
ImmutableSet.Builder<BuildTarget> deps = ImmutableSet.builder();
// Get any parse time deps from the C/C++ platforms.
deps.addAll(CxxPlatforms.getParseTimeDeps(cxxPlatforms.getValues()));
for (PythonPlatform pythonPlatform : pythonPlatforms.getValues()) {
deps.addAll(pythonPlatform.getCxxLibrary().asSet());
}
return deps.build();
}
/** Only works with thin binaries. */
private CxxPlatform getCxxPlatformForBuildTarget(BuildTarget target) {
CxxPlatform cxxPlatform;
try {
cxxPlatform = cxxPlatformFlavorDomain.getValue(target.getFlavors()).or(defaultCxxPlatform);
} catch (FlavorDomainException e) {
throw new HumanReadableException(e, "%s: %s", target, e.getMessage());
}
return cxxPlatform;
}
public static void assumeGoCompilerAvailable() throws InterruptedException, IOException {
Throwable exception = null;
try {
ProcessExecutor executor = new ProcessExecutor(new TestConsole());
new GoBuckConfig(
FakeBuckConfig.builder().build(),
executor,
FlavorDomain.from("Cxx", ImmutableSet.<CxxPlatform>of()))
.getCompiler();
} catch (HumanReadableException e) {
exception = e;
}
assumeNoException(exception);
}
@Override
public <A extends Arg> BuildRule createBuildRule(
TargetGraph targetGraph, BuildRuleParams params, BuildRuleResolver ruleResolver, A args) {
// See if we're building a particular "type" of this library, and if so, extract
// it as an enum.
Optional<Map.Entry<Flavor, Type>> type;
Optional<Map.Entry<Flavor, CxxPlatform>> platform;
try {
type =
LIBRARY_TYPE.getFlavorAndValue(ImmutableSet.copyOf(params.getBuildTarget().getFlavors()));
platform =
cxxPlatforms.getFlavorAndValue(ImmutableSet.copyOf(params.getBuildTarget().getFlavors()));
} catch (FlavorDomainException e) {
throw new HumanReadableException("%s: %s", params.getBuildTarget(), e.getMessage());
}
// If we *are* building a specific type of this lib, call into the type specific
// rule builder methods. Currently, we only support building a shared lib from the
// pre-existing static lib, which we do here.
if (type.isPresent()) {
Preconditions.checkState(type.get().getValue() == Type.EXTENSION);
Preconditions.checkState(platform.isPresent());
return createExtensionBuildRule(
targetGraph, params, ruleResolver, platform.get().getValue(), args);
}
// Otherwise, we return the generic placeholder of this library, that dependents can use
// get the real build rules via querying the action graph.
SourcePathResolver pathResolver = new SourcePathResolver(ruleResolver);
Path baseModule = PythonUtil.getBasePath(params.getBuildTarget(), args.baseModule);
return new CxxPythonExtension(
params,
ruleResolver,
pathResolver,
baseModule.resolve(getExtensionName(params.getBuildTarget())));
}
private <A extends Arg> BuildRule getFlavoredBinaryRule(
TargetGraph targetGraph,
final BuildRuleParams params,
final BuildRuleResolver resolver,
A args) {
// Cxx targets must have one Platform Flavor set otherwise nothing gets compiled.
ImmutableSet<Flavor> flavors =
params
.getBuildTarget()
.withoutFlavors(ImmutableSet.of(ReactNativeFlavors.DO_NOT_BUNDLE))
.getFlavors();
if (!cxxPlatformFlavorDomain.containsAnyOf(flavors)) {
flavors =
new ImmutableSet.Builder<Flavor>()
.addAll(flavors)
.add(defaultCxxPlatform.getFlavor())
.build();
}
final TargetNode<?> binaryTargetNode = Preconditions.checkNotNull(targetGraph.get(args.binary));
// If the binary target of the AppleBundle is an AppleLibrary then the build flavor
// must be specified.
if (binaryTargetNode.getDescription() instanceof AppleLibraryDescription
&& (Sets.intersection(
SUPPORTED_LIBRARY_FLAVORS, binaryTargetNode.getBuildTarget().getFlavors())
.size()
!= 1)) {
throw new HumanReadableException(
"AppleExtension bundle [%s] must have exactly one of these flavors: [%s].",
binaryTargetNode.getBuildTarget().toString(),
Joiner.on(", ").join(SUPPORTED_LIBRARY_FLAVORS));
}
BuildRuleParams binaryRuleParams =
new BuildRuleParams(
args.binary,
Suppliers.ofInstance(
BuildRules.toBuildRulesFor(
params.getBuildTarget(), resolver, binaryTargetNode.getDeclaredDeps())),
Suppliers.ofInstance(
BuildRules.toBuildRulesFor(
params.getBuildTarget(), resolver, binaryTargetNode.getExtraDeps())),
params.getProjectFilesystem(),
params.getCellRoots(),
params.getRuleKeyBuilderFactory());
return CxxDescriptionEnhancer.requireBuildRule(
targetGraph, binaryRuleParams, resolver, flavors.toArray(new Flavor[0]));
}
/** Propagate the bundle's platform flavors to its dependents. */
@Override
public ImmutableSet<BuildTarget> findDepsForTargetFromConstructorArgs(
BuildTarget buildTarget,
Function<Optional<String>, Path> cellRoots,
AppleBundleDescription.Arg constructorArg) {
if (!constructorArg.deps.isPresent()) {
return ImmutableSet.of();
}
if (!cxxPlatformFlavorDomain.containsAnyOf(buildTarget.getFlavors())) {
buildTarget =
BuildTarget.builder(buildTarget)
.addAllFlavors(ImmutableSet.of(defaultCxxPlatform.getFlavor()))
.build();
}
Optional<FatBinaryInfo> fatBinaryInfo =
FatBinaryInfo.create(platformFlavorsToAppleCxxPlatforms, buildTarget);
CxxPlatform cxxPlatform;
if (fatBinaryInfo.isPresent()) {
AppleCxxPlatform appleCxxPlatform = fatBinaryInfo.get().getRepresentativePlatform();
cxxPlatform = appleCxxPlatform.getCxxPlatform();
} else {
cxxPlatform = getCxxPlatformForBuildTarget(buildTarget);
}
String platformName = cxxPlatform.getFlavor().getName();
final Flavor actualWatchFlavor;
if (ApplePlatform.isSimulator(platformName)) {
actualWatchFlavor = ImmutableFlavor.builder().name("watchsimulator-i386").build();
} else if (platformName.startsWith(ApplePlatform.Name.IPHONEOS)
|| platformName.startsWith(ApplePlatform.Name.WATCHOS)) {
actualWatchFlavor = ImmutableFlavor.builder().name("watchos-armv7k").build();
} else {
actualWatchFlavor = ImmutableFlavor.builder().name(platformName).build();
}
FluentIterable<BuildTarget> depsExcludingBinary =
FluentIterable.from(constructorArg.deps.get())
.filter(Predicates.not(Predicates.equalTo(constructorArg.binary)));
FluentIterable<BuildTarget> targetsWithPlatformFlavors =
depsExcludingBinary.filter(BuildTargets.containsFlavors(cxxPlatformFlavorDomain));
FluentIterable<BuildTarget> targetsWithoutPlatformFlavors =
depsExcludingBinary.filter(
Predicates.not(BuildTargets.containsFlavors(cxxPlatformFlavorDomain)));
FluentIterable<BuildTarget> watchTargets =
targetsWithoutPlatformFlavors
.filter(BuildTargets.containsFlavor(WATCH))
.transform(
new Function<BuildTarget, BuildTarget>() {
@Override
public BuildTarget apply(BuildTarget input) {
return BuildTarget.builder(input.withoutFlavors(ImmutableSet.of(WATCH)))
.addFlavors(actualWatchFlavor)
.build();
}
});
targetsWithoutPlatformFlavors =
targetsWithoutPlatformFlavors.filter(Predicates.not(BuildTargets.containsFlavor(WATCH)));
return ImmutableSet.<BuildTarget>builder()
.addAll(targetsWithPlatformFlavors)
.addAll(watchTargets)
.addAll(
BuildTargets.propagateFlavorDomains(
buildTarget,
ImmutableSet.<FlavorDomain<?>>of(cxxPlatformFlavorDomain),
targetsWithoutPlatformFlavors))
.build();
}
@Override
public <A extends Arg> BuildRule createBuildRule(
TargetGraph targetGraph,
final BuildRuleParams params,
final BuildRuleResolver ruleResolver,
final A args)
throws NoSuchBuildTargetException {
// See if we're building a particular "type" of this library, and if so, extract
// it as an enum.
final Optional<Map.Entry<Flavor, Type>> type =
LIBRARY_TYPE.getFlavorAndValue(params.getBuildTarget());
Optional<Map.Entry<Flavor, CxxPlatform>> platform =
cxxPlatforms.getFlavorAndValue(params.getBuildTarget());
final Optional<Map.Entry<Flavor, PythonPlatform>> pythonPlatform =
pythonPlatforms.getFlavorAndValue(params.getBuildTarget());
// If we *are* building a specific type of this lib, call into the type specific
// rule builder methods. Currently, we only support building a shared lib from the
// pre-existing static lib, which we do here.
if (type.isPresent() && platform.isPresent() && pythonPlatform.isPresent()) {
Preconditions.checkState(type.get().getValue() == Type.EXTENSION);
return createExtensionBuildRule(
params.copyWithDeps(
Suppliers.ofInstance(
ImmutableSortedSet.copyOf(
getPlatformDeps(
params, ruleResolver, pythonPlatform.get().getValue(), args))),
Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())),
ruleResolver,
pythonPlatform.get().getValue(),
platform.get().getValue(),
args);
}
// Otherwise, we return the generic placeholder of this library, that dependents can use
// get the real build rules via querying the action graph.
final SourcePathResolver pathResolver = new SourcePathResolver(ruleResolver);
Path baseModule = PythonUtil.getBasePath(params.getBuildTarget(), args.baseModule);
final Path module = baseModule.resolve(getExtensionName(params.getBuildTarget()));
return new CxxPythonExtension(params, pathResolver) {
@Override
protected BuildRule getExtension(PythonPlatform pythonPlatform, CxxPlatform cxxPlatform)
throws NoSuchBuildTargetException {
return ruleResolver.requireRule(
getBuildTarget()
.withFlavors(
pythonPlatform.getFlavor(),
cxxPlatform.getFlavor(),
CxxDescriptionEnhancer.SHARED_FLAVOR));
}
@Override
public Path getModule() {
return module;
}
@Override
public PythonPackageComponents getPythonPackageComponents(
PythonPlatform pythonPlatform, CxxPlatform cxxPlatform)
throws NoSuchBuildTargetException {
BuildRule extension = getExtension(pythonPlatform, cxxPlatform);
SourcePath output = new BuildTargetSourcePath(extension.getBuildTarget());
return PythonPackageComponents.of(
ImmutableMap.of(module, output),
ImmutableMap.<Path, SourcePath>of(),
ImmutableMap.<Path, SourcePath>of(),
ImmutableSet.<SourcePath>of(),
Optional.of(false));
}
@Override
public SharedNativeLinkTarget getNativeLinkTarget(final PythonPlatform pythonPlatform) {
return new SharedNativeLinkTarget() {
@Override
public BuildTarget getBuildTarget() {
return params.getBuildTarget().withAppendedFlavors(pythonPlatform.getFlavor());
}
@Override
public Iterable<? extends NativeLinkable> getSharedNativeLinkTargetDeps(
CxxPlatform cxxPlatform) {
return FluentIterable.from(getPlatformDeps(params, ruleResolver, pythonPlatform, args))
.filter(NativeLinkable.class);
}
@Override
public Optional<String> getSharedNativeLinkTargetLibraryName(CxxPlatform cxxPlatform) {
return Optional.absent();
}
@Override
public NativeLinkableInput getSharedNativeLinkTargetInput(CxxPlatform cxxPlatform)
throws NoSuchBuildTargetException {
return NativeLinkableInput.builder()
.addAllArgs(
getExtensionArgs(
params.copyWithChanges(
params
.getBuildTarget()
.withAppendedFlavors(
pythonPlatform.getFlavor(),
CxxDescriptionEnhancer.SHARED_FLAVOR),
Suppliers.ofInstance(
ImmutableSortedSet.copyOf(
getPlatformDeps(params, ruleResolver, pythonPlatform, args))),
Suppliers.ofInstance(ImmutableSortedSet.<BuildRule>of())),
ruleResolver,
pathResolver,
cxxPlatform,
args))
.addAllFrameworks(args.frameworks.or(ImmutableSortedSet.<FrameworkPath>of()))
.build();
}
};
}
@Override
public ImmutableSortedSet<BuildRule> getRuntimeDeps() {
return getDeclaredDeps();
}
};
}