/**
* @param targetGraph input graph.
* @return module graph corresponding to the supplied {@link TargetGraph}. Multiple targets from
* the same base path are mapped to a single module, therefore an IjModuleGraph edge exists
* between two modules (Ma, Mb) if a TargetGraph edge existed between a pair of nodes (Ta, Tb)
* and Ma contains Ta and Mb contains Tb.
*/
public static IjModuleGraph from(
final TargetGraph targetGraph,
final IjLibraryFactory libraryFactory,
final IjModuleFactory moduleFactory) {
final ImmutableMap<BuildTarget, IjModule> rulesToModules =
createModules(targetGraph, moduleFactory);
final ExportedDepsClosureResolver exportedDepsClosureResolver =
new ExportedDepsClosureResolver(targetGraph);
ImmutableMap.Builder<IjProjectElement, ImmutableMap<IjProjectElement, DependencyType>>
depsBuilder = ImmutableMap.builder();
final Set<IjLibrary> referencedLibraries = new HashSet<>();
for (final IjModule module : FluentIterable.from(rulesToModules.values()).toSet()) {
Map<IjProjectElement, DependencyType> moduleDeps = new HashMap<>();
for (Map.Entry<BuildTarget, DependencyType> entry : module.getDependencies().entrySet()) {
BuildTarget depBuildTarget = entry.getKey();
DependencyType depType = entry.getValue();
ImmutableSet<IjProjectElement> depElements;
if (depType.equals(DependencyType.COMPILED_SHADOW)) {
TargetNode<?> targetNode = Preconditions.checkNotNull(targetGraph.get(depBuildTarget));
Optional<IjLibrary> library = libraryFactory.getLibrary(targetNode);
if (library.isPresent()) {
depElements = ImmutableSet.<IjProjectElement>of(library.get());
} else {
depElements = ImmutableSet.of();
}
} else {
depElements =
FluentIterable.from(
exportedDepsClosureResolver.getExportedDepsClosure(depBuildTarget))
.append(depBuildTarget)
.filter(
new Predicate<BuildTarget>() {
@Override
public boolean apply(BuildTarget input) {
// The exported deps closure can contain references back to targets
// contained
// in the module, so filter those out.
TargetNode<?> targetNode = targetGraph.get(input);
return !module.getTargets().contains(targetNode);
}
})
.transform(
new Function<BuildTarget, IjProjectElement>() {
@Nullable
@Override
public IjProjectElement apply(BuildTarget depTarget) {
IjModule depModule = rulesToModules.get(depTarget);
if (depModule != null) {
return depModule;
}
TargetNode<?> targetNode =
Preconditions.checkNotNull(targetGraph.get(depTarget));
IjLibrary library = libraryFactory.getLibrary(targetNode).orNull();
return library;
}
})
.filter(Predicates.notNull())
.toSet();
}
for (IjProjectElement depElement : depElements) {
Preconditions.checkState(!depElement.equals(module));
DependencyType.putWithMerge(moduleDeps, depElement, depType);
}
}
if (!module.getExtraClassPathDependencies().isEmpty()) {
IjLibrary extraClassPathLibrary =
IjLibrary.builder()
.setClassPaths(module.getExtraClassPathDependencies())
.setTargets(ImmutableSet.<TargetNode<?>>of())
.setName("library_" + module.getName() + "_extra_classpath")
.build();
moduleDeps.put(extraClassPathLibrary, DependencyType.PROD);
}
referencedLibraries.addAll(
FluentIterable.from(moduleDeps.keySet()).filter(IjLibrary.class).toSet());
depsBuilder.put(module, ImmutableMap.copyOf(moduleDeps));
}
for (IjLibrary library : referencedLibraries) {
depsBuilder.put(library, ImmutableMap.<IjProjectElement, DependencyType>of());
}
return new IjModuleGraph(depsBuilder.build());
}
@Test
@SuppressWarnings("unchecked")
public void testDependencies() throws Exception {
TargetNode<?> hamcrestTargetNode =
PrebuiltJarBuilder.createBuilder(
BuildTargetFactory.newInstance("//third-party/hamcrest:hamcrest"))
.setBinaryJar(Paths.get("third-party/hamcrest/hamcrest.jar"))
.build();
TargetNode<?> guavaTargetNode =
PrebuiltJarBuilder.createBuilder(
BuildTargetFactory.newInstance("//third-party/guava:guava"))
.setBinaryJar(Paths.get("third-party/guava/guava.jar"))
.build();
TargetNode<?> baseTargetNode =
JavaLibraryBuilder.createBuilder(
BuildTargetFactory.newInstance("//java/com/example/base:base"))
.addDep(guavaTargetNode.getBuildTarget())
.addSrc(Paths.get("java/com/example/base/Base.java"))
.build();
TargetNode<?> baseGenruleTarget =
GenruleBuilder.newGenruleBuilder(
BuildTargetFactory.newInstance("//java/com/example/base:genrule"))
.build();
TargetNode<?> baseInlineTestsTargetNode =
JavaLibraryBuilder.createBuilder(
BuildTargetFactory.newInstance("//java/com/example/base:tests"))
.addDep(hamcrestTargetNode.getBuildTarget())
.addSrc(Paths.get("java/com/example/base/TestBase.java"))
.addSrcTarget(baseGenruleTarget.getBuildTarget())
.build();
TargetNode<?> baseTestsTargetNode =
JavaTestBuilder.createBuilder(
BuildTargetFactory.newInstance("//javatests/com/example/base:base"))
.addDep(baseTargetNode.getBuildTarget())
.addDep(hamcrestTargetNode.getBuildTarget())
.addSrc(Paths.get("javatests/com/example/base/Base.java"))
.build();
IjModuleGraph moduleGraph =
IjModuleGraphTest.createModuleGraph(
ImmutableSet.of(
hamcrestTargetNode,
guavaTargetNode,
baseTargetNode,
baseGenruleTarget,
baseInlineTestsTargetNode,
baseTestsTargetNode),
ImmutableMap.<TargetNode<?>, Path>of(
baseInlineTestsTargetNode, Paths.get("buck-out/baseInlineTests.jar")),
Functions.constant(Optional.<Path>absent()));
IjLibrary hamcrestLibrary =
IjModuleGraphTest.getLibraryForTarget(moduleGraph, hamcrestTargetNode);
IjLibrary guavaLibrary = IjModuleGraphTest.getLibraryForTarget(moduleGraph, guavaTargetNode);
IjModule baseModule = IjModuleGraphTest.getModuleForTarget(moduleGraph, baseTargetNode);
IjModule baseTestModule =
IjModuleGraphTest.getModuleForTarget(moduleGraph, baseTestsTargetNode);
IjProjectTemplateDataPreparer dataPreparer =
new IjProjectTemplateDataPreparer(javaPackageFinder, moduleGraph, filesystem);
assertEquals(
IjModuleGraphTest.getModuleForTarget(moduleGraph, baseInlineTestsTargetNode),
IjModuleGraphTest.getModuleForTarget(moduleGraph, baseTargetNode));
DependencyEntryData.Builder dependencyEntryBuilder =
DependencyEntryData.builder().setExported(false);
assertThat(
dataPreparer.getDependencies(baseModule),
contains(
allOf(
hasProperty("type", equalTo(IjDependencyListBuilder.Type.LIBRARY)),
hasProperty(
"data",
equalTo(
Optional.of(
dependencyEntryBuilder
.setName(guavaLibrary.getName())
.setScope(IjDependencyListBuilder.Scope.COMPILE)
.build())))),
allOf(
hasProperty("type", equalTo(IjDependencyListBuilder.Type.LIBRARY)),
hasProperty(
"data",
equalTo(
Optional.of(
dependencyEntryBuilder
.setName(hamcrestLibrary.getName())
.setScope(IjDependencyListBuilder.Scope.COMPILE)
.build())))),
allOf(hasProperty("type", equalTo(IjDependencyListBuilder.Type.SOURCE_FOLDER))),
allOf(
hasProperty("type", equalTo(IjDependencyListBuilder.Type.LIBRARY)),
hasProperty(
"data",
equalTo(
Optional.of(
DependencyEntryData.builder()
.setExported(true)
.setName("library_java_com_example_base_tests")
.setScope(IjDependencyListBuilder.Scope.PROVIDED)
.build()))))));
assertThat(
dataPreparer.getDependencies(baseTestModule),
contains(
allOf(
hasProperty("type", equalTo(IjDependencyListBuilder.Type.MODULE)),
hasProperty(
"data",
equalTo(
Optional.of(
dependencyEntryBuilder
.setName(baseModule.getName())
.setScope(IjDependencyListBuilder.Scope.TEST)
.build())))),
allOf(
hasProperty("type", equalTo(IjDependencyListBuilder.Type.LIBRARY)),
hasProperty(
"data",
equalTo(
Optional.of(
dependencyEntryBuilder
.setName(hamcrestLibrary.getName())
.setScope(IjDependencyListBuilder.Scope.TEST)
.build())))),
allOf(hasProperty("type", equalTo(IjDependencyListBuilder.Type.SOURCE_FOLDER)))));
}
