public ImmutableMap<String, String> getEntriesForSection(String section) {
ImmutableMap<String, String> entries = config.get(section);
if (entries != null) {
return entries;
} else {
return ImmutableMap.of();
}
}
private static ImmutableSet<PathOrGlobMatcher> extractIgnorePaths(
final Path root, Config config) {
ImmutableSet.Builder<PathOrGlobMatcher> builder = ImmutableSet.builder();
builder.add(new PathOrGlobMatcher(root, ".idea"));
final String projectKey = "project";
final String ignoreKey = "ignore";
String buckdDirProperty = System.getProperty(BUCK_BUCKD_DIR_KEY, ".buckd");
if (!Strings.isNullOrEmpty(buckdDirProperty)) {
builder.add(new PathOrGlobMatcher(root, buckdDirProperty));
}
Path cacheDir = getCacheDir(root, config.getValue("cache", "dir"));
builder.add(new PathOrGlobMatcher(cacheDir));
builder.addAll(
FluentIterable.from(config.getListWithoutComments(projectKey, ignoreKey))
.transform(
new Function<String, PathOrGlobMatcher>() {
@Nullable
@Override
public PathOrGlobMatcher apply(String input) {
// We don't really want to ignore the output directory when doing things like
// filesystem
// walks, so return null
if (BuckConstant.BUCK_OUTPUT_DIRECTORY.equals(input)) {
return null; // root.getFileSystem().getPathMatcher("glob:**");
}
if (GLOB_CHARS.matcher(input).find()) {
return new PathOrGlobMatcher(
root.getFileSystem().getPathMatcher("glob:" + input), input);
}
return new PathOrGlobMatcher(root, input);
}
})
// And now remove any null patterns
.filter(Predicates.<PathOrGlobMatcher>notNull())
.toList());
return builder.build();
}
public Optional<Float> getRemoteLogSampleRate() {
Optional<Float> sampleRate = config.getFloat("log", "remote_log_sample_rate");
if (sampleRate.isPresent()) {
if (sampleRate.get() > 1.0f) {
throw new HumanReadableException(
".buckconfig: remote_log_sample_rate should be less than or equal to 1.0.");
}
if (sampleRate.get() < 0.0f) {
throw new HumanReadableException(
".buckconfig: remote_log_sample_rate should be greater than or equal to 0.");
}
}
return sampleRate;
}
@Test
public void shouldFindNeededDependenciesFromSymbols() throws IOException, InterruptedException {
ProjectWorkspace workspace =
TestDataHelper.createProjectWorkspaceForScenario(this, "symbol_finder", temporaryFolder);
workspace.setUp();
ProjectFilesystem projectFilesystem = new ProjectFilesystem(temporaryFolder.getRootPath());
ImmutableMap<String, String> environment = ImmutableMap.copyOf(System.getenv());
Config rawConfig =
Config.createDefaultConfig(
projectFilesystem.getRootPath(),
ImmutableMap.<String, ImmutableMap<String, String>>of());
BuckConfig config =
new BuckConfig(
rawConfig, projectFilesystem, Architecture.detect(), Platform.detect(), environment);
ImmutableSet<Description<?>> allDescriptions =
DefaultKnownBuildRuleTypes.getDefaultKnownBuildRuleTypes(projectFilesystem)
.getAllDescriptions();
BuckEventBus buckEventBus = BuckEventBusFactory.newInstance();
MissingSymbolsHandler missingSymbolsHandler =
MissingSymbolsHandler.create(
projectFilesystem,
allDescriptions,
config,
buckEventBus,
new TestConsole(),
DEFAULT_JAVAC_OPTIONS,
environment);
MissingSymbolEvent missingSymbolEvent =
MissingSymbolEvent.create(
BuildTargetFactory.newInstance(workspace.getDestPath(), "//java/com/example/b:b"),
"com.example.a.A",
MissingSymbolEvent.SymbolType.Java);
ImmutableSetMultimap<BuildTarget, BuildTarget> neededDeps =
missingSymbolsHandler.getNeededDependencies(ImmutableList.of(missingSymbolEvent));
assertEquals(
"MissingSymbolsHandler failed to find the needed dependency.",
neededDeps,
ImmutableSetMultimap.of(
BuildTargetFactory.newInstance(workspace.getDestPath(), "//java/com/example/b:b"),
BuildTargetFactory.newInstance(workspace.getDestPath(), "//java/com/example/a:a")));
}
/**
* Create a map of {@link BuildTarget} base paths to aliases. Note that there may be more than one
* alias to a base path, so the first one listed in the .buckconfig will be chosen.
*/
public ImmutableMap<Path, String> getBasePathToAliasMap() {
ImmutableMap<String, String> aliases = config.get(ALIAS_SECTION_HEADER);
if (aliases == null) {
return ImmutableMap.of();
}
// Build up the Map with an ordinary HashMap because we need to be able to check whether the Map
// already contains the key before inserting.
Map<Path, String> basePathToAlias = Maps.newHashMap();
for (Map.Entry<String, BuildTarget> entry : aliasToBuildTargetMap.entrySet()) {
String alias = entry.getKey();
BuildTarget buildTarget = entry.getValue();
Path basePath = buildTarget.getBasePath();
if (!basePathToAlias.containsKey(basePath)) {
basePathToAlias.put(basePath, alias);
}
}
return ImmutableMap.copyOf(basePathToAlias);
}
public ImmutableSet<String> getSections() {
return config.getSectionToEntries().keySet();
}
/** @return the maximum load limit that Buck should stay under on the system. */
public float getLoadLimit() {
return config.getFloat("build", "load_limit").or(Float.POSITIVE_INFINITY);
}
/**
* @return the number of threads Buck should use or the specified defaultValue if it is not set.
*/
public int getNumThreads(int defaultValue) {
return config.getLong("build", "threads").or((long) defaultValue).intValue();
}
public boolean getBooleanValue(String sectionName, String propertyName, boolean defaultValue) {
return config.getBooleanValue(sectionName, propertyName, defaultValue);
}
public Optional<Long> getLong(String sectionName, String propertyName) {
return config.getLong(sectionName, propertyName);
}
public Optional<String> getValue(String sectionName, String propertyName) {
return config.getValue(sectionName, propertyName);
}
public <T extends Enum<T>> Optional<T> getEnum(String section, String field, Class<T> clazz) {
return config.getEnum(section, field, clazz);
}
public ImmutableList<String> getListWithoutComments(String section, String field) {
return config.getListWithoutComments(section, field);
}