| /* |
| * Copyright 2012-present Facebook, Inc. |
| * |
| * 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.facebook.buck.cli; |
| |
| import com.facebook.buck.apple.AppleBuildRules; |
| import com.facebook.buck.apple.AppleTestDescription; |
| import com.facebook.buck.apple.ProjectGenerator; |
| import com.facebook.buck.apple.WorkspaceAndProjectGenerator; |
| import com.facebook.buck.apple.XcodeWorkspaceConfigDescription; |
| import com.facebook.buck.java.JavaLibraryDescription; |
| import com.facebook.buck.java.intellij.Project; |
| import com.facebook.buck.json.BuildFileParseException; |
| import com.facebook.buck.log.Logger; |
| import com.facebook.buck.model.BuildTarget; |
| import com.facebook.buck.model.BuildTargetException; |
| import com.facebook.buck.model.FilesystemBackedBuildFileTree; |
| import com.facebook.buck.model.HasBuildTarget; |
| import com.facebook.buck.parser.BuildTargetSpec; |
| import com.facebook.buck.parser.ParserConfig; |
| import com.facebook.buck.parser.TargetNodePredicateSpec; |
| import com.facebook.buck.parser.TargetNodeSpec; |
| import com.facebook.buck.python.PythonBuckConfig; |
| import com.facebook.buck.rules.ActionGraph; |
| import com.facebook.buck.rules.AssociatedTargetNodePredicate; |
| import com.facebook.buck.rules.BuildRuleResolver; |
| import com.facebook.buck.rules.ProjectConfig; |
| import com.facebook.buck.rules.SourcePathResolver; |
| import com.facebook.buck.rules.TargetGraph; |
| import com.facebook.buck.rules.TargetGraphAndTargets; |
| import com.facebook.buck.rules.TargetGraphToActionGraph; |
| import com.facebook.buck.rules.TargetGraphTransformer; |
| import com.facebook.buck.rules.TargetNode; |
| import com.facebook.buck.step.ExecutionContext; |
| import com.facebook.buck.util.HumanReadableException; |
| import com.facebook.buck.util.ProcessManager; |
| import com.google.common.annotations.VisibleForTesting; |
| import com.google.common.base.Charsets; |
| import com.google.common.base.Functions; |
| import com.google.common.base.Optional; |
| import com.google.common.base.Preconditions; |
| import com.google.common.base.Predicate; |
| import com.google.common.base.Predicates; |
| import com.google.common.collect.FluentIterable; |
| import com.google.common.collect.ImmutableList; |
| import com.google.common.collect.ImmutableSet; |
| import com.google.common.collect.Iterables; |
| import com.google.common.collect.Sets; |
| import com.google.common.io.Files; |
| |
| import java.io.BufferedReader; |
| import java.io.File; |
| import java.io.IOException; |
| import java.io.InputStreamReader; |
| import java.nio.file.Path; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| public class ProjectCommand extends AbstractCommandRunner<ProjectCommandOptions> { |
| |
| private static final Logger LOG = Logger.get(ProjectCommand.class); |
| |
| /** |
| * Include java library targets (and android library targets) that use annotation |
| * processing. The sources generated by these annotation processors is needed by |
| * IntelliJ. |
| */ |
| private static final Predicate<TargetNode<?>> ANNOTATION_PREDICATE = |
| new Predicate<TargetNode<?>>() { |
| @Override |
| public boolean apply(TargetNode<?> input) { |
| if (input.getType() != JavaLibraryDescription.TYPE) { |
| return false; |
| } |
| JavaLibraryDescription.Arg arg = ((JavaLibraryDescription.Arg) input.getConstructorArg()); |
| return !arg.annotationProcessors.get().isEmpty(); |
| } |
| }; |
| |
| private static final String XCODE_PROCESS_NAME = "Xcode"; |
| |
| private final TargetGraphTransformer<ActionGraph> targetGraphTransformer; |
| |
| public ProjectCommand(CommandRunnerParams params) { |
| super(params); |
| |
| this.targetGraphTransformer = new TargetGraphToActionGraph( |
| params.getBuckEventBus(), |
| new BuildTargetNodeToBuildRuleTransformer()); |
| } |
| |
| @Override |
| ProjectCommandOptions createOptions(BuckConfig buckConfig) { |
| return new ProjectCommandOptions(buckConfig); |
| } |
| |
| @Override |
| int runCommandWithOptionsInternal(ProjectCommandOptions options) |
| throws IOException, InterruptedException { |
| if (options.getIde() == ProjectCommandOptions.Ide.XCODE) { |
| checkForAndKillXcodeIfRunning(options.getIdePrompt()); |
| } |
| |
| ImmutableSet<BuildTarget> passedInTargetsSet = |
| getBuildTargets(options.getArgumentsFormattedAsBuildTargets()); |
| ProjectGraphParser projectGraphParser = ProjectGraphParsers.createProjectGraphParser( |
| getParser(), |
| new ParserConfig(options.getBuckConfig()), |
| getBuckEventBus(), |
| console, |
| environment, |
| options.getEnableProfiling()); |
| |
| TargetGraph projectGraph = projectGraphParser.buildTargetGraphForTargetNodeSpecs( |
| getTargetNodeSpecsForIde( |
| options.getIde(), |
| passedInTargetsSet, |
| getProjectFilesystem().getIgnorePaths())); |
| |
| ProjectPredicates projectPredicates = ProjectPredicates.forIde(options.getIde()); |
| |
| ImmutableSet<BuildTarget> graphRoots; |
| if (!passedInTargetsSet.isEmpty()) { |
| graphRoots = passedInTargetsSet; |
| } else { |
| graphRoots = getRootsFromPredicate( |
| projectGraph, |
| projectPredicates.getProjectRootsPredicate()); |
| } |
| |
| TargetGraphAndTargets targetGraphAndTargets = createTargetGraph( |
| projectGraph, |
| graphRoots, |
| projectGraphParser, |
| projectPredicates.getAssociatedProjectPredicate(), |
| options.isWithTests(), |
| options.getIde(), |
| getProjectFilesystem().getIgnorePaths()); |
| |
| if (options.getDryRun()) { |
| for (TargetNode<?> targetNode : targetGraphAndTargets.getTargetGraph().getNodes()) { |
| console.getStdOut().println(targetNode.toString()); |
| } |
| |
| return 0; |
| } |
| |
| switch (options.getIde()) { |
| case INTELLIJ: |
| return runIntellijProjectGenerator( |
| projectGraph, |
| targetGraphAndTargets, |
| passedInTargetsSet, |
| options); |
| case XCODE: |
| return runXcodeProjectGenerator( |
| targetGraphAndTargets, |
| passedInTargetsSet, |
| options); |
| default: |
| // unreachable |
| throw new IllegalStateException("'ide' should always be of type 'INTELLIJ' or 'XCODE'"); |
| } |
| } |
| |
| /** |
| * Run intellij specific project generation actions. |
| */ |
| int runIntellijProjectGenerator( |
| TargetGraph projectGraph, |
| TargetGraphAndTargets targetGraphAndTargets, |
| ImmutableSet<BuildTarget> passedInTargetsSet, |
| ProjectCommandOptions options) |
| throws IOException, InterruptedException { |
| // Create an ActionGraph that only contains targets that can be represented as IDE |
| // configuration files. |
| ActionGraph actionGraph = targetGraphTransformer.apply(targetGraphAndTargets.getTargetGraph()); |
| |
| try (ExecutionContext executionContext = createExecutionContext()) { |
| Project project = new Project( |
| new SourcePathResolver(new BuildRuleResolver(actionGraph.getNodes())), |
| FluentIterable |
| .from(actionGraph.getNodes()) |
| .filter(ProjectConfig.class) |
| .toSet(), |
| actionGraph, |
| options.getBasePathToAliasMap(), |
| options.getJavaPackageFinder(), |
| executionContext, |
| new FilesystemBackedBuildFileTree( |
| getProjectFilesystem(), |
| new ParserConfig(options.getBuckConfig()).getBuildFileName()), |
| getProjectFilesystem(), |
| options.getPathToDefaultAndroidManifest(), |
| options.getPathToPostProcessScript(), |
| new PythonBuckConfig(options.getBuckConfig()).getPythonInterpreter(), |
| getObjectMapper(), |
| options.isAndroidAutoGenerateEnabled()); |
| |
| File tempDir = Files.createTempDir(); |
| File tempFile = new File(tempDir, "project.json"); |
| int exitCode; |
| try { |
| exitCode = project.createIntellijProject( |
| tempFile, |
| executionContext.getProcessExecutor(), |
| !passedInTargetsSet.isEmpty(), |
| console.getStdOut(), |
| console.getStdErr()); |
| if (exitCode != 0) { |
| return exitCode; |
| } |
| |
| List<String> additionalInitialTargets = ImmutableList.of(); |
| if (options.shouldProcessAnnotations()) { |
| try { |
| additionalInitialTargets = getAnnotationProcessingTargets( |
| projectGraph, |
| passedInTargetsSet); |
| } catch (BuildTargetException | BuildFileParseException e) { |
| throw new HumanReadableException(e); |
| } |
| } |
| |
| // Build initial targets. |
| if (options.hasInitialTargets() || !additionalInitialTargets.isEmpty()) { |
| BuildCommand buildCommand = new BuildCommand(getCommandRunnerParams()); |
| BuildCommandOptions buildOptions = |
| options.createBuildCommandOptionsWithInitialTargets(additionalInitialTargets); |
| |
| |
| exitCode = buildCommand.runCommandWithOptions(buildOptions); |
| if (exitCode != 0) { |
| return exitCode; |
| } |
| } |
| } finally { |
| // Either leave project.json around for debugging or delete it on exit. |
| if (console.getVerbosity().shouldPrintOutput()) { |
| getStdErr().printf("project.json was written to %s", tempFile.getAbsolutePath()); |
| } else { |
| tempFile.delete(); |
| tempDir.delete(); |
| } |
| } |
| |
| if (passedInTargetsSet.isEmpty()) { |
| String greenStar = console.getAnsi().asHighlightedSuccessText(" * "); |
| getStdErr().printf( |
| console.getAnsi().asHighlightedSuccessText("=== Did you know ===") + "\n" + |
| greenStar + "You can run `buck project <target>` to generate a minimal project " + |
| "just for that target.\n" + |
| greenStar + "This will make your IDE faster when working on large projects.\n" + |
| greenStar + "See buck project --help for more info.\n" + |
| console.getAnsi().asHighlightedSuccessText( |
| "--=* Knowing is half the battle!") + "\n"); |
| } |
| |
| return 0; |
| } |
| } |
| |
| ImmutableList<String> getAnnotationProcessingTargets( |
| TargetGraph projectGraph, |
| ImmutableSet<BuildTarget> passedInTargetsSet) |
| throws BuildTargetException, BuildFileParseException, IOException, InterruptedException { |
| ImmutableSet<BuildTarget> buildTargets; |
| if (!passedInTargetsSet.isEmpty()) { |
| buildTargets = passedInTargetsSet; |
| } else { |
| buildTargets = getRootsFromPredicate( |
| projectGraph, |
| ANNOTATION_PREDICATE); |
| } |
| return FluentIterable |
| .from(buildTargets) |
| .transform(Functions.toStringFunction()) |
| .toList(); |
| } |
| |
| /** |
| * Run xcode specific project generation actions. |
| */ |
| int runXcodeProjectGenerator( |
| TargetGraphAndTargets targetGraphAndTargets, |
| ImmutableSet<BuildTarget> passedInTargetsSet, |
| ProjectCommandOptions options) |
| throws IOException, InterruptedException { |
| ImmutableSet.Builder<ProjectGenerator.Option> optionsBuilder = ImmutableSet.builder(); |
| if (options.getReadOnly()) { |
| optionsBuilder.add(ProjectGenerator.Option.GENERATE_READ_ONLY_FILES); |
| } |
| if (options.isWithTests()) { |
| optionsBuilder.add(ProjectGenerator.Option.INCLUDE_TESTS); |
| } |
| |
| boolean combinedProject = options.getCombinedProject(); |
| ImmutableSet<BuildTarget> targets; |
| if (passedInTargetsSet.isEmpty()) { |
| targets = FluentIterable |
| .from(targetGraphAndTargets.getProjectRoots()) |
| .transform(HasBuildTarget.TO_TARGET) |
| .toSet(); |
| } else { |
| targets = passedInTargetsSet; |
| } |
| if (combinedProject) { |
| optionsBuilder.addAll(ProjectGenerator.COMBINED_PROJECT_OPTIONS); |
| } else { |
| optionsBuilder.addAll(ProjectGenerator.SEPARATED_PROJECT_OPTIONS); |
| } |
| LOG.debug("Generating workspace for config targets %s", targets); |
| Map<Path, ProjectGenerator> projectGenerators = new HashMap<>(); |
| ImmutableSet<TargetNode<?>> testTargetNodes = targetGraphAndTargets.getAssociatedTests(); |
| ImmutableSet<TargetNode<AppleTestDescription.Arg>> groupableTests = |
| options.getCombineTestBundles() |
| ? AppleBuildRules.filterGroupableTests(testTargetNodes) |
| : ImmutableSet.<TargetNode<AppleTestDescription.Arg>>of(); |
| for (BuildTarget workspaceTarget : targets) { |
| TargetNode<?> workspaceNode = Preconditions.checkNotNull( |
| targetGraphAndTargets.getTargetGraph().get(workspaceTarget)); |
| if (workspaceNode.getType() != XcodeWorkspaceConfigDescription.TYPE) { |
| throw new HumanReadableException( |
| "%s must be a xcode_workspace_config", |
| workspaceTarget); |
| } |
| WorkspaceAndProjectGenerator generator = new WorkspaceAndProjectGenerator( |
| getProjectFilesystem(), |
| targetGraphAndTargets.getTargetGraph(), |
| castToXcodeWorkspaceTargetNode(workspaceNode), |
| optionsBuilder.build(), |
| combinedProject, |
| new ParserConfig(options.getBuckConfig()).getBuildFileName()); |
| generator.setGroupableTests(groupableTests); |
| generator.generateWorkspaceAndDependentProjects(projectGenerators); |
| } |
| |
| return 0; |
| } |
| |
| @SuppressWarnings(value = "unchecked") |
| private static TargetNode<XcodeWorkspaceConfigDescription.Arg> castToXcodeWorkspaceTargetNode( |
| TargetNode<?> targetNode) { |
| Preconditions.checkArgument(targetNode.getType() == XcodeWorkspaceConfigDescription.TYPE); |
| return (TargetNode<XcodeWorkspaceConfigDescription.Arg>) targetNode; |
| } |
| |
| private void checkForAndKillXcodeIfRunning(boolean enablePrompt) |
| throws InterruptedException, IOException { |
| Optional<ProcessManager> processManager = getProcessManager(); |
| if (!processManager.isPresent()) { |
| LOG.warn("Could not check if Xcode is running (no process manager)"); |
| return; |
| } |
| |
| if (!processManager.get().isProcessRunning(XCODE_PROCESS_NAME)) { |
| LOG.debug("Xcode is not running."); |
| return; |
| } |
| |
| if (enablePrompt && canPrompt()) { |
| if (prompt( |
| "Xcode is currently running. Buck will modify files Xcode currently has " + |
| "open, which can cause it to become unstable.\n\n" + |
| "Kill Xcode and continue?")) { |
| processManager.get().killProcess(XCODE_PROCESS_NAME); |
| } else { |
| console.getStdOut().println( |
| console.getAnsi().asWarningText( |
| "Xcode is running. Generated projects might be lost or corrupted if Xcode " + |
| "currently has them open.")); |
| } |
| console.getStdOut().format( |
| "To disable this prompt in the future, add the following to %s: \n\n" + |
| "[project]\n" + |
| " ide_prompt = false\n\n", |
| getProjectFilesystem() |
| .getRootPath() |
| .resolve(BuckConfig.DEFAULT_BUCK_CONFIG_OVERRIDE_FILE_NAME) |
| .toAbsolutePath()); |
| } else { |
| LOG.debug( |
| "Xcode is running, but cannot prompt to kill it (enabled %s, can prompt %s)", |
| enablePrompt, canPrompt()); |
| } |
| } |
| |
| private boolean canPrompt() { |
| return System.console() != null; |
| } |
| |
| private boolean prompt(String prompt) throws IOException { |
| Preconditions.checkState(canPrompt()); |
| |
| LOG.debug("Displaying prompt %s..", prompt); |
| console.getStdOut().print(console.getAnsi().asWarningText(prompt + " [Y/n] ")); |
| |
| Optional<String> result; |
| try (InputStreamReader stdinReader = new InputStreamReader(System.in, Charsets.UTF_8); |
| BufferedReader bufferedStdinReader = new BufferedReader(stdinReader)) { |
| result = Optional.fromNullable(bufferedStdinReader.readLine()); |
| } |
| LOG.debug("Result of prompt: [%s]", result); |
| return result.isPresent() && |
| (result.get().isEmpty() || result.get().toLowerCase(Locale.US).startsWith("y")); |
| } |
| |
| @VisibleForTesting |
| static ImmutableSet<BuildTarget> getRootsFromPredicate( |
| TargetGraph projectGraph, |
| Predicate<TargetNode<?>> rootsPredicate) { |
| return FluentIterable |
| .from(projectGraph.getNodes()) |
| .filter(rootsPredicate) |
| .transform(HasBuildTarget.TO_TARGET) |
| .toSet(); |
| } |
| |
| private static Iterable<? extends TargetNodeSpec> getTargetNodeSpecsForIde( |
| ProjectCommandOptions.Ide ide, |
| Collection<BuildTarget> passedInBuildTargets, |
| ImmutableSet<Path> ignoreDirs |
| ) { |
| if (ide == ProjectCommandOptions.Ide.XCODE && |
| !passedInBuildTargets.isEmpty()) { |
| return Iterables.transform( |
| passedInBuildTargets, |
| BuildTargetSpec.TO_BUILD_TARGET_SPEC); |
| } else { |
| return ImmutableList.of( |
| new TargetNodePredicateSpec( |
| Predicates.<TargetNode<?>>alwaysTrue(), |
| ignoreDirs)); |
| } |
| } |
| |
| private static TargetGraphAndTargets createTargetGraph( |
| TargetGraph projectGraph, |
| ImmutableSet<BuildTarget> graphRoots, |
| ProjectGraphParser projectGraphParser, |
| AssociatedTargetNodePredicate associatedProjectPredicate, |
| boolean isWithTests, |
| ProjectCommandOptions.Ide ide, |
| ImmutableSet<Path> ignoreDirs |
| ) |
| throws IOException, InterruptedException { |
| |
| TargetGraph resultProjectGraph; |
| ImmutableSet<BuildTarget> explicitTestTargets; |
| |
| if (isWithTests) { |
| explicitTestTargets = TargetGraphAndTargets.getExplicitTestTargets( |
| graphRoots, |
| projectGraph); |
| resultProjectGraph = |
| projectGraphParser.buildTargetGraphForTargetNodeSpecs( |
| getTargetNodeSpecsForIde( |
| ide, |
| Sets.union(graphRoots, explicitTestTargets), |
| ignoreDirs)); |
| } else { |
| resultProjectGraph = projectGraph; |
| explicitTestTargets = ImmutableSet.of(); |
| } |
| |
| return TargetGraphAndTargets.create( |
| graphRoots, |
| resultProjectGraph, |
| associatedProjectPredicate, |
| isWithTests, |
| explicitTestTargets); |
| } |
| |
| @Override |
| String getUsageIntro() { |
| return "generates project configuration files for an IDE"; |
| } |
| |
| } |
