Import of bazel plugin using copybara
PiperOrigin-RevId: 145021219
diff --git a/BUILD b/BUILD
index f87b1dc..99282bc 100644
--- a/BUILD
+++ b/BUILD
@@ -10,6 +10,7 @@
tests = [
"//base:integration_tests",
"//base:unit_tests",
+ "//golang:unit_tests",
"//ijwb:integration_tests",
"//ijwb:unit_tests",
"//java:integration_tests",
diff --git a/WORKSPACE b/WORKSPACE
index edb340b..bad62f5 100644
--- a/WORKSPACE
+++ b/WORKSPACE
@@ -2,6 +2,14 @@
# Long-lived download links available at: https://www.jetbrains.com/intellij-repository/releases
+# The plugin api for IntelliJ 2016.3.1. This is required to build IJwB,
+# and run integration tests.
+new_http_archive(
+ name = "intellij_ce_2016_3_1",
+ build_file = "intellij_platform_sdk/BUILD.idea",
+ url = "https://www.jetbrains.com/intellij-repository/releases/com/jetbrains/intellij/idea/ideaIC/2016.3.1/ideaIC-2016.3.1.zip",
+)
+
# The plugin api for IntelliJ 2016.2.4. This is required to build IJwB,
# and run integration tests.
new_http_archive(
@@ -18,6 +26,30 @@
url = "https://download.jetbrains.com/cpp/CLion-2016.2.2.tar.gz",
)
+# The plugin api for CLion 2016.3.2. This is required to build CLwB,
+# and run integration tests.
+new_http_archive(
+ name = "clion_2016_3_2",
+ build_file = "intellij_platform_sdk/BUILD.clion",
+ url = "https://download.jetbrains.com/cpp/CLion-2016.3.2.tar.gz",
+)
+
+# The plugin api for Android Studio 2.3 Beta 1. This is required to build ASwB,
+# and run integration tests.
+new_http_archive(
+ name = "android_studio_2_3_0_3",
+ build_file = "intellij_platform_sdk/BUILD.android_studio",
+ url = "https://dl.google.com/dl/android/studio/ide-zips/2.3.0.3/android-studio-ide-162.3573574-linux.zip",
+)
+
+# The plugin api for Android Studio 2.3 Beta 2. This is required to build ASwB,
+# and run integration tests.
+new_http_archive(
+ name = "android_studio_2_3_0_4",
+ build_file = "intellij_platform_sdk/BUILD.android_studio",
+ url = "https://dl.google.com/dl/android/studio/ide-zips/2.3.0.4/android-studio-ide-162.3616766-linux.zip",
+)
+
# The plugin api for Android Studio 2.2 stable. This is required to build ASwB,
# and run integration tests.
new_http_archive(
diff --git a/aswb/2.2/src/com/google/idea/blaze/android/compatibility/Compatibility.java b/aswb/2.2/src/com/google/idea/blaze/android/compatibility/Compatibility.java
new file mode 100644
index 0000000..d65d9f2
--- /dev/null
+++ b/aswb/2.2/src/com/google/idea/blaze/android/compatibility/Compatibility.java
@@ -0,0 +1,138 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.compatibility;
+
+import com.android.sdklib.AndroidVersion;
+import com.android.tools.idea.run.ConsolePrinter;
+import com.android.tools.idea.run.editor.AndroidDebugger;
+import com.android.tools.idea.run.editor.AndroidDebuggerState;
+import com.android.tools.idea.run.tasks.DebugConnectorTask;
+import com.android.tools.idea.run.util.LaunchStatus;
+import com.intellij.execution.Executor;
+import com.intellij.execution.configurations.ConfigurationFactory;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.runners.ExecutionEnvironment;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.projectRoots.Sdk;
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+import org.jetbrains.android.facet.AndroidFacet;
+import org.jetbrains.android.sdk.AndroidSdkAdditionalData;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jps.android.model.impl.JpsAndroidModuleProperties;
+
+/** Compatibility facades for Android Studio 2.2. */
+public class Compatibility {
+ private Compatibility() {}
+ /**
+ * Facade for {@link org.jetbrains.android.sdk.AndroidSdkUtils} and {@link
+ * com.android.tools.idea.sdk.AndroidSdks#getInstance()}.
+ */
+ public static class AndroidSdkUtils {
+ private AndroidSdkUtils() {}
+
+ public static Sdk findSuitableAndroidSdk(String targetHash) {
+ return org.jetbrains.android.sdk.AndroidSdkUtils.findSuitableAndroidSdk(targetHash);
+ }
+
+ public static List<Sdk> getAllAndroidSdks() {
+ return org.jetbrains.android.sdk.AndroidSdkUtils.getAllAndroidSdks();
+ }
+
+ public static AndroidSdkAdditionalData getAndroidSdkAdditionalData(Sdk sdk) {
+ return org.jetbrains.android.sdk.AndroidSdkUtils.getAndroidSdkAdditionalData(sdk);
+ }
+ }
+
+ /**
+ * Facade for {@link com.android.tools.idea.sdk.IdeSdks} and {@link
+ * com.android.tools.idea.sdk.IdeSdks#getInstance()}.
+ */
+ public static class IdeSdks {
+ private IdeSdks() {}
+
+ public static File getAndroidSdkPath() {
+ return com.android.tools.idea.sdk.IdeSdks.getAndroidSdkPath();
+ }
+
+ public static List<Sdk> createAndroidSdkPerAndroidTarget(File androidSdkPath) {
+ return com.android.tools.idea.sdk.IdeSdks.createAndroidSdkPerAndroidTarget(androidSdkPath);
+ }
+ }
+
+ /**
+ * Facade for {@link com.android.tools.idea.run.testing.AndroidTestListener} and {@link
+ * com.android.tools.idea.testartifacts.instrumented.AndroidTestListener}
+ */
+ public static class AndroidTestListener
+ extends com.android.tools.idea.run.testing.AndroidTestListener {
+ public AndroidTestListener(LaunchStatus launchStatus, ConsolePrinter consolePrinter) {
+ super(launchStatus, consolePrinter);
+ }
+ }
+
+ /**
+ * Facade for {@link com.android.tools.idea.run.testing.AndroidTestConsoleProperties} and {@link
+ * com.android.tools.idea.testartifacts.instrumented.AndroidTestConsoleProperties}
+ */
+ public static class AndroidTestConsoleProperties
+ extends com.android.tools.idea.run.testing.AndroidTestConsoleProperties {
+ public AndroidTestConsoleProperties(RunConfiguration runConfiguration, Executor executor) {
+ super(runConfiguration, executor);
+ }
+ }
+
+ /**
+ * Facade for {@link com.android.tools.idea.run.testing.AndroidTestRunConfiguration} and {@link
+ * com.android.tools.idea.testartifacts.instrumented.AndroidTestRunConfiguration}
+ */
+ public static class AndroidTestRunConfiguration
+ extends com.android.tools.idea.run.testing.AndroidTestRunConfiguration {
+ public AndroidTestRunConfiguration(Project project, ConfigurationFactory configurationFactory) {
+ super(project, configurationFactory);
+ }
+ }
+
+ /** Facade for {@link com.android.tools.idea.run.tasks.ConnectDebuggerTask}. */
+ public abstract static class ConnectDebuggerTask
+ extends com.android.tools.idea.run.tasks.ConnectDebuggerTask {
+ protected ConnectDebuggerTask(
+ Set<String> applicationIds,
+ AndroidDebugger<?> debugger,
+ Project project,
+ boolean monitorRemoteProcess) {
+ super(applicationIds, debugger, project);
+ }
+ }
+
+ public static <S extends AndroidDebuggerState> DebugConnectorTask getConnectDebuggerTask(
+ AndroidDebugger<S> androidDebugger,
+ ExecutionEnvironment env,
+ @Nullable AndroidVersion version,
+ Set<String> applicationIds,
+ AndroidFacet facet,
+ S state,
+ String runConfigTypeId,
+ boolean monitorRemoteProcess) {
+ return androidDebugger.getConnectDebuggerTask(
+ env, version, applicationIds, facet, state, runConfigTypeId);
+ }
+
+ public static void setFacetStateIsLibraryProject(JpsAndroidModuleProperties facetState) {
+ facetState.LIBRARY_PROJECT = true;
+ }
+}
diff --git a/aswb/src/com/google/idea/blaze/android/sync/model/idea/NullClassJarProvider.java b/aswb/2.2/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java
similarity index 78%
rename from aswb/src/com/google/idea/blaze/android/sync/model/idea/NullClassJarProvider.java
rename to aswb/2.2/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java
index 037f4fa..20c2c22 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/model/idea/NullClassJarProvider.java
+++ b/aswb/2.2/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java
@@ -18,22 +18,23 @@
import com.android.tools.idea.model.ClassJarProvider;
import com.google.common.collect.ImmutableList;
import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import java.util.List;
-import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/** Returns no class jars. Used to disable the layout editor loading jars. */
-public class NullClassJarProvider extends ClassJarProvider {
+public class BlazeClassJarProvider extends ClassJarProvider {
+ public BlazeClassJarProvider(Project project) {}
+
@Nullable
@Override
- public VirtualFile findModuleClassFile(@NotNull String className, @NotNull Module module) {
+ public VirtualFile findModuleClassFile(String className, Module module) {
return null;
}
- @NotNull
@Override
- public List<VirtualFile> getModuleExternalLibraries(@NotNull Module module) {
+ public List<VirtualFile> getModuleExternalLibraries(Module module) {
return ImmutableList.of();
}
}
diff --git a/aswb/tests/utils/integration/com/google/idea/blaze/android/AndroidTestCleanupHelper.java b/aswb/2.2/tests/utils/integration/com/google/idea/blaze/android/AndroidTestCleanupHelper.java
similarity index 100%
rename from aswb/tests/utils/integration/com/google/idea/blaze/android/AndroidTestCleanupHelper.java
rename to aswb/2.2/tests/utils/integration/com/google/idea/blaze/android/AndroidTestCleanupHelper.java
diff --git a/aswb/tests/utils/integration/com/google/idea/blaze/android/AndroidTestSetupRule.java b/aswb/2.2/tests/utils/integration/com/google/idea/blaze/android/AndroidTestSetupRule.java
similarity index 100%
rename from aswb/tests/utils/integration/com/google/idea/blaze/android/AndroidTestSetupRule.java
rename to aswb/2.2/tests/utils/integration/com/google/idea/blaze/android/AndroidTestSetupRule.java
diff --git a/aswb/tests/utils/integration/com/google/idea/blaze/android/BlazeAndroidIntegrationTestCase.java b/aswb/2.2/tests/utils/integration/com/google/idea/blaze/android/BlazeAndroidIntegrationTestCase.java
similarity index 100%
rename from aswb/tests/utils/integration/com/google/idea/blaze/android/BlazeAndroidIntegrationTestCase.java
rename to aswb/2.2/tests/utils/integration/com/google/idea/blaze/android/BlazeAndroidIntegrationTestCase.java
diff --git a/aswb/2.3/src/META-INF/aswb_beta.xml b/aswb/2.3/src/META-INF/aswb_beta.xml
new file mode 100644
index 0000000..8df2945
--- /dev/null
+++ b/aswb/2.3/src/META-INF/aswb_beta.xml
@@ -0,0 +1,35 @@
+<!--
+ ~ Copyright 2016 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.
+ -->
+<idea-plugin>
+ <depends>com.google.gct.test.recorder</depends>
+
+ <extensions defaultExtensionNs="com.google.idea.blaze">
+ <BlazeUserSettingsContributor implementation="com.google.idea.blaze.android.settings.BlazeAndroidUserSettingsContributor$BlazeAndroidUserSettingsProvider"/>
+ </extensions>
+
+ <extensions defaultExtensionNs="com.android.project">
+ <buildSystemService implementation="com.google.idea.blaze.android.project.BlazeBuildSystemService"/>
+ <featureEnableService implementation="com.google.idea.blaze.android.project.BlazeFeatureEnableService"/>
+ </extensions>
+
+ <extensions defaultExtensionNs="com.android.rendering">
+ <renderErrorContributor implementation="com.google.idea.blaze.android.rendering.BlazeRenderErrorContributor$BlazeProvider"/>
+ </extensions>
+
+ <extensions defaultExtensionNs="com.google.gct.testrecorder.run">
+ <testRecorderRunConfigurationProxyProvider implementation="com.google.idea.blaze.android.run.testrecorder.TestRecorderBlazeCommandRunConfigurationProxyProvider" />
+ </extensions>
+</idea-plugin>
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/compatibility/Compatibility.java b/aswb/2.3/src/com/google/idea/blaze/android/compatibility/Compatibility.java
new file mode 100644
index 0000000..e614959
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/compatibility/Compatibility.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.compatibility;
+
+import com.android.sdklib.AndroidVersion;
+import com.android.tools.idea.run.ConsolePrinter;
+import com.android.tools.idea.run.editor.AndroidDebugger;
+import com.android.tools.idea.run.editor.AndroidDebuggerState;
+import com.android.tools.idea.run.tasks.DebugConnectorTask;
+import com.android.tools.idea.run.util.LaunchStatus;
+import com.intellij.execution.Executor;
+import com.intellij.execution.configurations.ConfigurationFactory;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.runners.ExecutionEnvironment;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.projectRoots.Sdk;
+import java.io.File;
+import java.util.List;
+import java.util.Set;
+import org.jetbrains.android.facet.AndroidFacet;
+import org.jetbrains.android.sdk.AndroidSdkAdditionalData;
+import org.jetbrains.annotations.Nullable;
+import org.jetbrains.jps.android.model.impl.JpsAndroidModuleProperties;
+
+/** Compatibility facades for Android Studio 2.3. */
+public class Compatibility {
+ private Compatibility() {}
+
+ /**
+ * Facade for {@link org.jetbrains.android.sdk.AndroidSdkUtils} and {@link
+ * com.android.tools.idea.sdk.AndroidSdks#getInstance()}.
+ */
+ public static class AndroidSdkUtils {
+ private AndroidSdkUtils() {}
+
+ public static Sdk findSuitableAndroidSdk(String targetHash) {
+ return com.android.tools.idea.sdk.AndroidSdks.getInstance()
+ .findSuitableAndroidSdk(targetHash);
+ }
+
+ public static List<Sdk> getAllAndroidSdks() {
+ return com.android.tools.idea.sdk.AndroidSdks.getInstance().getAllAndroidSdks();
+ }
+
+ public static AndroidSdkAdditionalData getAndroidSdkAdditionalData(Sdk sdk) {
+ return com.android.tools.idea.sdk.AndroidSdks.getInstance().getAndroidSdkAdditionalData(sdk);
+ }
+ }
+
+ /**
+ * Facade for {@link com.android.tools.idea.sdk.IdeSdks} and {@link
+ * com.android.tools.idea.sdk.IdeSdks#getInstance()}.
+ */
+ public static class IdeSdks {
+ private IdeSdks() {}
+
+ public static File getAndroidSdkPath() {
+ return com.android.tools.idea.sdk.IdeSdks.getInstance().getAndroidSdkPath();
+ }
+
+ public static List<Sdk> createAndroidSdkPerAndroidTarget(File androidSdkPath) {
+ return com.android.tools.idea.sdk.IdeSdks.getInstance()
+ .createAndroidSdkPerAndroidTarget(androidSdkPath);
+ }
+ }
+
+ /**
+ * Facade for {@link com.android.tools.idea.run.testing.AndroidTestListener} and {@link
+ * com.android.tools.idea.testartifacts.instrumented.AndroidTestListener}
+ */
+ public static class AndroidTestListener
+ extends com.android.tools.idea.testartifacts.instrumented.AndroidTestListener {
+ public AndroidTestListener(LaunchStatus launchStatus, ConsolePrinter consolePrinter) {
+ super(launchStatus, consolePrinter);
+ }
+ }
+
+ /**
+ * Facade for {@link com.android.tools.idea.run.testing.AndroidTestConsoleProperties} and {@link
+ * com.android.tools.idea.testartifacts.instrumented.AndroidTestConsoleProperties}
+ */
+ public static class AndroidTestConsoleProperties
+ extends com.android.tools.idea.testartifacts.instrumented.AndroidTestConsoleProperties {
+ public AndroidTestConsoleProperties(RunConfiguration runConfiguration, Executor executor) {
+ super(runConfiguration, executor);
+ }
+ }
+
+ /**
+ * Facade for {@link com.android.tools.idea.run.testing.AndroidTestRunConfiguration} and {@link
+ * com.android.tools.idea.testartifacts.instrumented.AndroidTestRunConfiguration}
+ */
+ public static class AndroidTestRunConfiguration
+ extends com.android.tools.idea.testartifacts.instrumented.AndroidTestRunConfiguration {
+ public AndroidTestRunConfiguration(Project project, ConfigurationFactory configurationFactory) {
+ super(project, configurationFactory);
+ }
+ }
+
+ /** Facade for {@link com.android.tools.idea.run.tasks.ConnectDebuggerTask}. */
+ public abstract static class ConnectDebuggerTask
+ extends com.android.tools.idea.run.tasks.ConnectDebuggerTask {
+ protected ConnectDebuggerTask(
+ Set<String> applicationIds,
+ AndroidDebugger<?> debugger,
+ Project project,
+ boolean monitorRemoteProcess) {
+ super(applicationIds, debugger, project, monitorRemoteProcess);
+ }
+ }
+
+ public static <S extends AndroidDebuggerState> DebugConnectorTask getConnectDebuggerTask(
+ AndroidDebugger<S> androidDebugger,
+ ExecutionEnvironment env,
+ @Nullable AndroidVersion version,
+ Set<String> applicationIds,
+ AndroidFacet facet,
+ S state,
+ String runConfigTypeId,
+ boolean monitorRemoteProcess) {
+ return androidDebugger.getConnectDebuggerTask(
+ env, version, applicationIds, facet, state, runConfigTypeId, monitorRemoteProcess);
+ }
+
+ public static void setFacetStateIsLibraryProject(JpsAndroidModuleProperties facetState) {
+ facetState.PROJECT_TYPE = com.android.builder.model.AndroidProject.PROJECT_TYPE_LIBRARY;
+ }
+}
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/project/BlazeBuildSystemService.java b/aswb/2.3/src/com/google/idea/blaze/android/project/BlazeBuildSystemService.java
new file mode 100644
index 0000000..36923d7
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/project/BlazeBuildSystemService.java
@@ -0,0 +1,99 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.project;
+
+import com.android.tools.idea.project.BuildSystemService;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry;
+import com.google.idea.blaze.base.actions.BlazeBuildService;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.lang.buildfile.references.BuildReferenceManager;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.sync.BlazeSyncManager;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.fileEditor.OpenFileDescriptor;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VfsUtil;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.ex.temp.TempFileSystem;
+import com.intellij.psi.PsiElement;
+import java.io.File;
+
+/** Blaze implementation of {@link BuildSystemService} for build system specific operations. */
+public class BlazeBuildSystemService extends BuildSystemService {
+ @Override
+ public boolean isApplicable(Project project) {
+ return Blaze.isBlazeProject(project);
+ }
+
+ @Override
+ public void buildProject(Project project) {
+ BlazeBuildService.getInstance().buildProject(project);
+ }
+
+ @Override
+ public void syncProject(Project project) {
+ BlazeSyncManager.getInstance(project).incrementalProjectSync();
+ }
+
+ @Override
+ public void addDependency(Module module, String artifact) {
+ Project project = module.getProject();
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+ if (blazeProjectData == null) {
+ return;
+ }
+ AndroidResourceModuleRegistry registry = AndroidResourceModuleRegistry.getInstance(project);
+ TargetIdeInfo targetIdeInfo = blazeProjectData.targetMap.get(registry.getTargetKey(module));
+ if (targetIdeInfo == null || targetIdeInfo.buildFile == null) {
+ return;
+ }
+
+ // TODO: automagically edit deps instead of just opening the BUILD file?
+ // Need to translate Gradle coordinates into blaze targets.
+ // Will probably need to hardcode for each dependency.
+ FileEditorManager fileEditorManager = FileEditorManager.getInstance(project);
+ PsiElement buildTargetPsi =
+ BuildReferenceManager.getInstance(project).resolveLabel(targetIdeInfo.key.label);
+ if (buildTargetPsi != null) {
+ // If we can find a PSI for the target,
+ // then we can jump straight to the target in the build file.
+ fileEditorManager.openTextEditor(
+ new OpenFileDescriptor(
+ project,
+ buildTargetPsi.getContainingFile().getVirtualFile(),
+ buildTargetPsi.getTextOffset()),
+ true);
+ } else {
+ // If not, just the build file is good enough.
+ File buildIoFile = blazeProjectData.artifactLocationDecoder.decode(targetIdeInfo.buildFile);
+ VirtualFile buildVirtualFile = findFileByIoFile(buildIoFile);
+ if (buildVirtualFile != null) {
+ fileEditorManager.openFile(buildVirtualFile, true);
+ }
+ }
+ }
+
+ private static VirtualFile findFileByIoFile(File file) {
+ return ApplicationManager.getApplication().isUnitTestMode()
+ ? TempFileSystem.getInstance().findFileByIoFile(file)
+ : VfsUtil.findFileByIoFile(file, true);
+ }
+}
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/project/BlazeFeatureEnableService.java b/aswb/2.3/src/com/google/idea/blaze/android/project/BlazeFeatureEnableService.java
new file mode 100644
index 0000000..e59f375
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/project/BlazeFeatureEnableService.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.project;
+
+import com.android.tools.idea.project.FeatureEnableService;
+import com.google.idea.blaze.android.settings.BlazeAndroidUserSettings;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.common.experiments.BoolExperiment;
+import com.intellij.openapi.project.Project;
+
+/** Enable features supported by the blaze integration. */
+public class BlazeFeatureEnableService extends FeatureEnableService {
+ private static final BoolExperiment ENABLE_LAYOUT_EDITOR =
+ new BoolExperiment("enable.layout.editor", true);
+
+ @Override
+ protected boolean isApplicable(Project project) {
+ return Blaze.isBlazeProject(project);
+ }
+
+ @Override
+ public boolean isLayoutEditorEnabled(Project project) {
+ return isLayoutEditorExperimentEnabled()
+ && BlazeAndroidUserSettings.getInstance().getUseLayoutEditor()
+ // Can't render if we don't have the data ready.
+ && BlazeProjectDataManager.getInstance(project).getBlazeProjectData() != null;
+ }
+
+ public static boolean isLayoutEditorExperimentEnabled() {
+ return ENABLE_LAYOUT_EDITOR.getValue();
+ }
+}
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/rendering/BlazeRenderErrorContributor.java b/aswb/2.3/src/com/google/idea/blaze/android/rendering/BlazeRenderErrorContributor.java
new file mode 100644
index 0000000..b4c8498
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/rendering/BlazeRenderErrorContributor.java
@@ -0,0 +1,338 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.rendering;
+
+import static com.android.SdkConstants.ANDROID_MANIFEST_XML;
+
+import com.android.tools.idea.rendering.HtmlLinkManager;
+import com.android.tools.idea.rendering.RenderErrorContributor;
+import com.android.tools.idea.rendering.RenderLogger;
+import com.android.tools.idea.rendering.RenderResult;
+import com.android.tools.idea.rendering.errors.ui.RenderErrorModel;
+import com.android.utils.HtmlBuilder;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.Maps;
+import com.google.common.collect.SortedSetMultimap;
+import com.google.common.collect.TreeMultimap;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModule;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry;
+import com.google.idea.blaze.base.ideinfo.ArtifactLocation;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.lang.buildfile.references.BuildReferenceManager;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
+import com.google.idea.blaze.base.targetmaps.SourceToTargetMap;
+import com.google.idea.blaze.base.targetmaps.TransitiveDependencyMap;
+import com.intellij.lang.annotation.HighlightSeverity;
+import com.intellij.openapi.actionSystem.DataContext;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.IndexNotReadyException;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Computable;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.VfsUtilCore;
+import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.search.GlobalSearchScope;
+import java.io.File;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
+import java.util.SortedMap;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+import org.jetbrains.annotations.Nullable;
+
+/** Contribute blaze specific render errors. */
+public class BlazeRenderErrorContributor extends RenderErrorContributor {
+ private RenderLogger logger;
+ private Module module;
+ private Project project;
+
+ public BlazeRenderErrorContributor(RenderResult result, @Nullable DataContext dataContext) {
+ super(result, dataContext);
+ logger = result.getLogger();
+ module = result.getModule();
+ project = module.getProject();
+ }
+
+ @Override
+ public Collection<RenderErrorModel.Issue> reportIssues() {
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+
+ if (blazeProjectData == null || !logger.hasErrors()) {
+ return getIssues();
+ }
+
+ TargetMap targetMap = blazeProjectData.targetMap;
+ ArtifactLocationDecoder decoder = blazeProjectData.artifactLocationDecoder;
+ AndroidResourceModule resourceModule =
+ AndroidResourceModuleRegistry.getInstance(project).get(module);
+ if (resourceModule == null) {
+ return getIssues();
+ }
+
+ TargetIdeInfo target = targetMap.get(resourceModule.targetKey);
+ if (target == null) {
+ return getIssues();
+ }
+
+ reportGeneratedResources(resourceModule, targetMap, decoder);
+ reportNonStandardAndroidManifestName(target, decoder);
+ reportResourceTargetShouldDependOnClassTarget(target, targetMap, decoder);
+ return getIssues();
+ }
+
+ /**
+ * We can't find generated resources. If a layout uses them, the layout won't render correctly.
+ */
+ private void reportGeneratedResources(
+ AndroidResourceModule resourceModule, TargetMap targetMap, ArtifactLocationDecoder decoder) {
+ Map<String, Throwable> brokenClasses = logger.getBrokenClasses();
+ if (brokenClasses == null || brokenClasses.isEmpty()) {
+ return;
+ }
+
+ // Sorted entries for deterministic error message.
+ SortedMap<ArtifactLocation, TargetIdeInfo> generatedResources =
+ Maps.newTreeMap(getGeneratedResources(targetMap.get(resourceModule.targetKey)));
+
+ for (TargetKey dependency : resourceModule.transitiveResourceDependencies) {
+ generatedResources.putAll(getGeneratedResources(targetMap.get(dependency)));
+ }
+
+ if (generatedResources.isEmpty()) {
+ return;
+ }
+
+ HtmlBuilder builder = new HtmlBuilder();
+ builder.add("Generated resources will not be discovered by the IDE:");
+ builder.beginList();
+ for (Map.Entry<ArtifactLocation, TargetIdeInfo> entry : generatedResources.entrySet()) {
+ ArtifactLocation resource = entry.getKey();
+ TargetIdeInfo target = entry.getValue();
+ builder.listItem().add(resource.getRelativePath()).add(" from ");
+ addTargetLink(builder, target, decoder);
+ }
+ builder
+ .endList()
+ .add("Please avoid using generated resources, ")
+ .addLink("then ", "sync the project", " ", getLinkManager().createSyncProjectUrl())
+ .addLink("and ", "refresh the layout", ".", getLinkManager().createRefreshRenderUrl());
+ addIssue()
+ .setSeverity(HighlightSeverity.ERROR, HIGH_PRIORITY + 1) // Reported above broken classes
+ .setSummary("Generated resources")
+ .setHtmlContent(builder)
+ .build();
+ }
+
+ private static SortedMap<ArtifactLocation, TargetIdeInfo> getGeneratedResources(
+ TargetIdeInfo target) {
+ if (target == null || target.androidIdeInfo == null) {
+ return Collections.emptySortedMap();
+ }
+ SortedMap<ArtifactLocation, TargetIdeInfo> generatedResources = Maps.newTreeMap();
+ generatedResources.putAll(
+ target
+ .androidIdeInfo
+ .resources
+ .stream()
+ .filter(ArtifactLocation::isGenerated)
+ .collect(Collectors.toMap(Function.identity(), resource -> target)));
+ return generatedResources;
+ }
+
+ /**
+ * When the Android manifest isn't AndroidManifest.xml, resolving resource IDs would fail. This
+ * doesn't seem to be an issue if the manifest belongs to one of the target's dependencies.
+ */
+ private void reportNonStandardAndroidManifestName(
+ TargetIdeInfo target, ArtifactLocationDecoder decoder) {
+ if (target.androidIdeInfo == null || target.androidIdeInfo.manifest == null) {
+ return;
+ }
+
+ Map<String, Throwable> brokenClasses = logger.getBrokenClasses();
+ if (brokenClasses == null || brokenClasses.isEmpty()) {
+ return;
+ }
+
+ File manifest = decoder.decode(target.androidIdeInfo.manifest);
+ if (manifest.getName().equals(ANDROID_MANIFEST_XML)) {
+ return;
+ }
+
+ HtmlBuilder builder = new HtmlBuilder();
+ addTargetLink(builder, target, decoder)
+ .add(" uses a non-standard name for the Android manifest: ");
+ String linkToManifest = HtmlLinkManager.createFilePositionUrl(manifest, -1, 0);
+ if (linkToManifest != null) {
+ builder.addLink(manifest.getName(), linkToManifest);
+ } else {
+ builder.newline().add(manifest.getPath());
+ }
+ // TODO: add a link to automatically rename the file and refactor all references.
+ builder
+ .newline()
+ .add("Please rename it to ")
+ .add(ANDROID_MANIFEST_XML)
+ .addLink(", then ", "sync the project", "", getLinkManager().createSyncProjectUrl())
+ .addLink(" and ", "refresh the layout", ".", getLinkManager().createRefreshRenderUrl());
+ addIssue()
+ .setSeverity(HighlightSeverity.ERROR, HIGH_PRIORITY + 1) // Reported above broken classes.
+ .setSummary("Non-standard manifest name")
+ .setHtmlContent(builder)
+ .build();
+ }
+
+ /**
+ * Blaze doesn't resolve class dependencies from resources until building the final
+ * android_binary, so we could end up with resources that ultimately build correctly, but fail to
+ * find their class dependencies during rendering in the layout editor.
+ */
+ private void reportResourceTargetShouldDependOnClassTarget(
+ TargetIdeInfo target, TargetMap targetMap, ArtifactLocationDecoder decoder) {
+ Collection<String> missingClasses = logger.getMissingClasses();
+ if (missingClasses == null || missingClasses.isEmpty()) {
+ return;
+ }
+
+ // Sorted entries for deterministic error message.
+ SortedSetMultimap<String, TargetKey> missingClassToTargetMap = TreeMultimap.create();
+
+ SourceToTargetMap sourceToTargetMap = SourceToTargetMap.getInstance(project);
+ ImmutableCollection transitiveDependencies =
+ TransitiveDependencyMap.getInstance(project).getTransitiveDependencies(target.key);
+
+ for (String missingClass : missingClasses) {
+ File sourceFile = getSourceFileForClass(missingClass);
+ if (sourceFile == null) {
+ continue;
+ }
+ ImmutableCollection<TargetKey> sourceTargets =
+ sourceToTargetMap.getRulesForSourceFile(sourceFile);
+ if (sourceTargets
+ .stream()
+ .noneMatch(
+ sourceTarget ->
+ sourceTarget.equals(target.key)
+ || transitiveDependencies.contains(sourceTarget))) {
+ missingClassToTargetMap.putAll(missingClass, sourceTargets);
+ }
+ }
+
+ if (missingClassToTargetMap.isEmpty()) {
+ return;
+ }
+
+ HtmlBuilder builder = new HtmlBuilder();
+ addTargetLink(builder, target, decoder)
+ .add(" contains resource files that reference these classes:")
+ .beginList();
+ for (String missingClass : missingClassToTargetMap.keySet()) {
+ builder
+ .listItem()
+ .addLink(missingClass, getLinkManager().createOpenClassUrl(missingClass))
+ .add(" from ");
+ for (TargetKey targetKey : missingClassToTargetMap.get(missingClass)) {
+ addTargetLink(builder, targetMap.get(targetKey), decoder).add(" ");
+ }
+ }
+ builder.endList().add("Please fix your dependencies so that ");
+ addTargetLink(builder, target, decoder)
+ .add(" correctly depends on these classes, ")
+ .addLink("then ", "sync the project", " ", getLinkManager().createSyncProjectUrl())
+ .addLink("and ", "refresh the layout", ".", getLinkManager().createRefreshRenderUrl())
+ .newline()
+ .newline()
+ .addBold(
+ "NOTE: blaze can still build with the incorrect dependencies "
+ + "due to the way it handles resources, "
+ + "but the layout editor needs them to be correct.");
+
+ addIssue()
+ .setSeverity(HighlightSeverity.ERROR, HIGH_PRIORITY + 1) // Reported above missing classes.
+ .setSummary("Missing class dependencies")
+ .setHtmlContent(builder)
+ .build();
+ }
+
+ private File getSourceFileForClass(String className) {
+ return ApplicationManager.getApplication()
+ .runReadAction(
+ (Computable<File>)
+ () -> {
+ try {
+ PsiClass psiClass =
+ JavaPsiFacade.getInstance(project)
+ .findClass(className, GlobalSearchScope.projectScope(project));
+ if (psiClass == null) {
+ return null;
+ }
+ return VfsUtilCore.virtualToIoFile(
+ psiClass.getContainingFile().getVirtualFile());
+ } catch (IndexNotReadyException ignored) {
+ // We're in dumb mode. Abort! Abort!
+ return null;
+ }
+ });
+ }
+
+ private HtmlBuilder addTargetLink(
+ HtmlBuilder builder, TargetIdeInfo target, ArtifactLocationDecoder decoder) {
+ File buildFile = decoder.decode(target.buildFile);
+ int line =
+ ApplicationManager.getApplication()
+ .runReadAction(
+ (Computable<Integer>)
+ () -> {
+ PsiElement buildTargetPsi =
+ BuildReferenceManager.getInstance(project).resolveLabel(target.key.label);
+ if (buildTargetPsi == null) {
+ return -1;
+ }
+ return StringUtil.offsetToLineNumber(
+ buildTargetPsi.getContainingFile().getText(),
+ buildTargetPsi.getTextOffset());
+ });
+ String url = HtmlLinkManager.createFilePositionUrl(buildFile, line, 0);
+ if (url != null) {
+ return builder.addLink(target.toString(), url);
+ }
+ return builder.add(target.toString());
+ }
+
+ /** Extension to provide {@link BlazeRenderErrorContributor}. */
+ public static class BlazeProvider extends Provider {
+ @Override
+ public boolean isApplicable(Project project) {
+ return Blaze.isBlazeProject(project);
+ }
+
+ @Override
+ public RenderErrorContributor getContributor(
+ RenderResult result, @Nullable DataContext dataContext) {
+ return new BlazeRenderErrorContributor(result, dataContext);
+ }
+ }
+}
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfiguration.java b/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfiguration.java
new file mode 100644
index 0000000..2f6c62e
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfiguration.java
@@ -0,0 +1,40 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.run.testrecorder;
+
+import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
+import com.intellij.openapi.diagnostic.Logger;
+import org.jdom.Element;
+
+/** Blaze integration with test recorder. */
+public class TestRecorderBlazeCommandRunConfiguration extends BlazeCommandRunConfiguration {
+ private static final Logger LOGGER =
+ Logger.getInstance(TestRecorderBlazeCommandRunConfiguration.class);
+
+ public TestRecorderBlazeCommandRunConfiguration(BlazeCommandRunConfiguration baseConfiguration) {
+ super(
+ baseConfiguration.getProject(),
+ baseConfiguration.getFactory(),
+ "TestRecorder" + baseConfiguration.getName());
+ Element element = new Element("toClone");
+ try {
+ baseConfiguration.writeExternal(element);
+ this.readExternal(element);
+ } catch (Exception e) {
+ LOGGER.error(e);
+ }
+ }
+}
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfigurationProxy.java b/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfigurationProxy.java
new file mode 100644
index 0000000..b91a720
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfigurationProxy.java
@@ -0,0 +1,83 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.run.testrecorder;
+
+import com.android.annotations.Nullable;
+import com.android.ddmlib.IDevice;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.gct.testrecorder.run.TestRecorderRunConfigurationProxy;
+import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationHandler;
+import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationState;
+import com.google.idea.blaze.android.run.runner.BlazeAndroidRunConfigurationRunner;
+import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
+import com.intellij.execution.configurations.LocatableConfigurationBase;
+import com.intellij.execution.runners.ExecutionEnvironment;
+import com.intellij.openapi.module.Module;
+import java.util.List;
+
+/** {@link TestRecorderRunConfigurationProxy} for blaze. */
+public class TestRecorderBlazeCommandRunConfigurationProxy
+ implements TestRecorderRunConfigurationProxy {
+
+ private final BlazeCommandRunConfiguration myBaseConfiguration;
+ private final BlazeAndroidBinaryRunConfigurationHandler myBaseConfigurationHandler;
+
+ public TestRecorderBlazeCommandRunConfigurationProxy(
+ BlazeCommandRunConfiguration baseConfiguration) {
+ myBaseConfiguration = baseConfiguration;
+ myBaseConfigurationHandler =
+ (BlazeAndroidBinaryRunConfigurationHandler) baseConfiguration.getHandler();
+ }
+
+ @Override
+ public LocatableConfigurationBase getTestRecorderRunConfiguration() {
+ return new TestRecorderBlazeCommandRunConfiguration(myBaseConfiguration);
+ }
+
+ @Override
+ public Module getModule() {
+ return myBaseConfigurationHandler.getModule();
+ }
+
+ @Override
+ public boolean isLaunchActivitySupported() {
+ String mode = myBaseConfigurationHandler.getState().getMode();
+
+ // Supported launch activities are Default and Specified.
+ return BlazeAndroidBinaryRunConfigurationState.LAUNCH_DEFAULT_ACTIVITY.equals(mode)
+ || BlazeAndroidBinaryRunConfigurationState.LAUNCH_SPECIFIC_ACTIVITY.equals(mode);
+ }
+
+ @Override
+ public String getLaunchActivityClass() {
+ BlazeAndroidBinaryRunConfigurationState state = myBaseConfigurationHandler.getState();
+
+ if (BlazeAndroidBinaryRunConfigurationState.LAUNCH_SPECIFIC_ACTIVITY.equals(state.getMode())) {
+ return state.getActivityClass();
+ }
+
+ return "";
+ }
+
+ @Nullable
+ @Override
+ public List<ListenableFuture<IDevice>> getDeviceFutures(ExecutionEnvironment environment) {
+ return environment
+ .getCopyableUserData(BlazeAndroidRunConfigurationRunner.DEVICE_SESSION_KEY)
+ .deviceFutures
+ .get();
+ }
+}
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfigurationProxyProvider.java b/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfigurationProxyProvider.java
new file mode 100644
index 0000000..8a2c206
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/run/testrecorder/TestRecorderBlazeCommandRunConfigurationProxyProvider.java
@@ -0,0 +1,41 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.run.testrecorder;
+
+import com.android.annotations.Nullable;
+import com.google.gct.testrecorder.run.TestRecorderRunConfigurationProxy;
+import com.google.gct.testrecorder.run.TestRecorderRunConfigurationProxyProvider;
+import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationHandler;
+import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
+import com.intellij.execution.configurations.RunConfiguration;
+
+/** Provides {@link TestRecorderBlazeCommandRunConfigurationProxy}. */
+public class TestRecorderBlazeCommandRunConfigurationProxyProvider
+ implements TestRecorderRunConfigurationProxyProvider {
+
+ @Nullable
+ @Override
+ public TestRecorderRunConfigurationProxy getProxy(@Nullable RunConfiguration runConfiguration) {
+ if (runConfiguration instanceof BlazeCommandRunConfiguration
+ && ((BlazeCommandRunConfiguration) runConfiguration).getHandler()
+ instanceof BlazeAndroidBinaryRunConfigurationHandler) {
+ return new TestRecorderBlazeCommandRunConfigurationProxy(
+ (BlazeCommandRunConfiguration) runConfiguration);
+ }
+
+ return null;
+ }
+}
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/settings/BlazeAndroidUserSettingsContributor.java b/aswb/2.3/src/com/google/idea/blaze/android/settings/BlazeAndroidUserSettingsContributor.java
new file mode 100644
index 0000000..3ff141b
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/settings/BlazeAndroidUserSettingsContributor.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.settings;
+
+import com.google.common.base.Objects;
+import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.android.project.BlazeFeatureEnableService;
+import com.google.idea.blaze.base.settings.ui.BlazeUserSettingsContributor;
+import com.intellij.uiDesigner.core.GridConstraints;
+import javax.swing.JCheckBox;
+import javax.swing.JComponent;
+import javax.swing.JPanel;
+
+/** Contributes Android-specific settings. */
+public class BlazeAndroidUserSettingsContributor implements BlazeUserSettingsContributor {
+ private final ImmutableList<JComponent> components;
+ private JCheckBox useLayoutEditor;
+
+ BlazeAndroidUserSettingsContributor() {
+ useLayoutEditor = new JCheckBox();
+ useLayoutEditor.setSelected(false);
+ useLayoutEditor.setText("Use the layout editor for layout XML files. May freeze IDE.");
+
+ ImmutableList.Builder<JComponent> builder = ImmutableList.builder();
+ if (BlazeFeatureEnableService.isLayoutEditorExperimentEnabled()) {
+ builder.add(useLayoutEditor);
+ }
+ components = builder.build();
+ }
+
+ @Override
+ public void apply() {
+ BlazeAndroidUserSettings settings = BlazeAndroidUserSettings.getInstance();
+ settings.setUseLayoutEditor(useLayoutEditor.isSelected());
+ }
+
+ @Override
+ public void reset() {
+ BlazeAndroidUserSettings settings = BlazeAndroidUserSettings.getInstance();
+ useLayoutEditor.setSelected(settings.getUseLayoutEditor());
+ }
+
+ @Override
+ public boolean isModified() {
+ BlazeAndroidUserSettings settings = BlazeAndroidUserSettings.getInstance();
+ return !Objects.equal(useLayoutEditor.isSelected(), settings.getUseLayoutEditor());
+ }
+
+ @Override
+ public int getRowCount() {
+ return components.size();
+ }
+
+ @Override
+ public int addComponents(JPanel panel, int rowi) {
+ for (JComponent contributedComponent : components) {
+ panel.add(
+ contributedComponent,
+ new GridConstraints(
+ rowi++,
+ 0,
+ 1,
+ 2,
+ GridConstraints.ANCHOR_NORTHWEST,
+ GridConstraints.FILL_NONE,
+ GridConstraints.SIZEPOLICY_CAN_SHRINK | GridConstraints.SIZEPOLICY_CAN_GROW,
+ GridConstraints.SIZEPOLICY_FIXED,
+ null,
+ null,
+ null,
+ 0,
+ false));
+ }
+ return rowi;
+ }
+
+ static class BlazeAndroidUserSettingsProvider implements Provider {
+ @Override
+ public BlazeUserSettingsContributor getContributor() {
+ return new BlazeAndroidUserSettingsContributor();
+ }
+ }
+}
diff --git a/aswb/2.3/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java b/aswb/2.3/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java
new file mode 100644
index 0000000..15c2add
--- /dev/null
+++ b/aswb/2.3/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java
@@ -0,0 +1,224 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.sync.model.idea;
+
+import com.android.SdkConstants;
+import com.android.tools.idea.model.ClassJarProvider;
+import com.android.tools.idea.res.AppResourceRepository;
+import com.android.tools.idea.res.ResourceClassRegistry;
+import com.google.common.collect.Lists;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry;
+import com.google.idea.blaze.base.ideinfo.AndroidIdeInfo;
+import com.google.idea.blaze.base.ideinfo.JavaIdeInfo;
+import com.google.idea.blaze.base.ideinfo.LibraryArtifact;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
+import com.google.idea.blaze.base.targetmaps.TransitiveDependencyMap;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.ModalityState;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.JarFileSystem;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.ex.temp.TempFileSystem;
+import com.intellij.util.containers.OrderedSet;
+import java.io.File;
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.atomic.AtomicBoolean;
+import org.jetbrains.annotations.Nullable;
+
+/** Collects class jars from the user's build. */
+public class BlazeClassJarProvider extends ClassJarProvider {
+
+ private final Project project;
+ private AtomicBoolean pendingModuleJarsRefresh;
+ private AtomicBoolean pendingDependencyJarsRefresh;
+
+ public BlazeClassJarProvider(final Project project) {
+ this.project = project;
+ this.pendingModuleJarsRefresh = new AtomicBoolean(false);
+ this.pendingDependencyJarsRefresh = new AtomicBoolean(false);
+ }
+
+ @Override
+ @Nullable
+ public VirtualFile findModuleClassFile(String className, Module module) {
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+ if (blazeProjectData == null) {
+ return null;
+ }
+
+ ArtifactLocationDecoder decoder = blazeProjectData.artifactLocationDecoder;
+ AndroidResourceModuleRegistry registry = AndroidResourceModuleRegistry.getInstance(project);
+ TargetIdeInfo target = blazeProjectData.targetMap.get(registry.getTargetKey(module));
+
+ if (target == null || target.javaIdeInfo == null) {
+ return null;
+ }
+
+ // As a potential optimization, we could choose an arbitrary android_binary target
+ // that depends on the library to provide a single complete resource jar,
+ // instead of having to rely on dynamic class generation.
+ // TODO: benchmark to see if optimization is worthwhile.
+
+ String classNamePath = className.replace('.', File.separatorChar) + SdkConstants.DOT_CLASS;
+
+ List<File> missingClassJars = Lists.newArrayList();
+ for (LibraryArtifact jar : target.javaIdeInfo.jars) {
+ if (jar.classJar == null) {
+ continue;
+ }
+ File classJarFile = decoder.decode(jar.classJar);
+ VirtualFile classJarVF = findFileByIoFile(classJarFile);
+ if (classJarVF == null) {
+ if (classJarFile.exists()) {
+ missingClassJars.add(classJarFile);
+ }
+ continue;
+ }
+ VirtualFile classFile = findClassInJar(classJarVF, classNamePath);
+ if (classFile != null) {
+ return classFile;
+ }
+ }
+
+ maybeRefreshJars(missingClassJars, pendingModuleJarsRefresh);
+ return null;
+ }
+
+ @Nullable
+ private static VirtualFile findClassInJar(final VirtualFile classJar, String classNamePath) {
+ VirtualFile jarRoot = getJarRootForLocalFile(classJar);
+ if (jarRoot == null) {
+ return null;
+ }
+ return jarRoot.findFileByRelativePath(classNamePath);
+ }
+
+ @Override
+ public List<VirtualFile> getModuleExternalLibraries(Module module) {
+ OrderedSet<VirtualFile> results = new OrderedSet<>();
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+
+ if (blazeProjectData == null) {
+ return results;
+ }
+
+ TargetMap targetMap = blazeProjectData.targetMap;
+ ArtifactLocationDecoder decoder = blazeProjectData.artifactLocationDecoder;
+
+ AndroidResourceModuleRegistry registry = AndroidResourceModuleRegistry.getInstance(project);
+ TargetIdeInfo target = targetMap.get(registry.getTargetKey(module));
+
+ if (target == null) {
+ return results;
+ }
+
+ AppResourceRepository repository = AppResourceRepository.getAppResources(module, true);
+
+ List<File> missingClassJars = Lists.newArrayList();
+ for (TargetKey dependencyTargetKey :
+ TransitiveDependencyMap.getInstance(project).getTransitiveDependencies(target.key)) {
+ TargetIdeInfo dependencyTarget = targetMap.get(dependencyTargetKey);
+ if (dependencyTarget == null) {
+ continue;
+ }
+ JavaIdeInfo javaIdeInfo = dependencyTarget.javaIdeInfo;
+ AndroidIdeInfo androidIdeInfo = dependencyTarget.androidIdeInfo;
+
+ // Add all non-resource jars to be searched.
+ // Multiple resource jars will have ID conflicts unless generated dynamically.
+ if (javaIdeInfo != null) {
+ for (LibraryArtifact jar : javaIdeInfo.jars) {
+ if (androidIdeInfo != null && jar.equals(androidIdeInfo.resourceJar)) {
+ // No resource jars.
+ continue;
+ }
+ // Some of these could be empty class jars from resource only android_library targets.
+ // A potential optimization could be to filter out jars like these,
+ // so we don't waste time fetching and searching them.
+ // TODO: benchmark to see if optimization is worthwhile.
+ if (jar.classJar != null) {
+ File classJarFile = decoder.decode(jar.classJar);
+ VirtualFile classJar = findFileByIoFile(classJarFile);
+ if (classJar != null) {
+ results.add(classJar);
+ } else if (classJarFile.exists()) {
+ missingClassJars.add(classJarFile);
+ }
+ }
+ }
+ }
+
+ // Tell ResourceClassRegistry which repository contains our resources and the java packages of
+ // the resources that we're interested in.
+ // When the class loader tries to load a custom view, and the view references resource
+ // classes, layoutlib will ask the class loader for these resource classes.
+ // If these resource classes are in a separate jar from the target (i.e., in a dependency),
+ // then offering their jars will lead to a conflict in the resource IDs.
+ // So instead, the resource class generator will produce dummy resource classes with
+ // non-conflicting IDs to satisfy the class loader.
+ // The resource repository remembers the dynamic IDs that it handed out and when the layoutlib
+ // calls to ask about the name and content of a given resource ID, the repository can just
+ // answer what it has already stored.
+ if (androidIdeInfo != null && repository != null) {
+ ResourceClassRegistry.get(module.getProject())
+ .addLibrary(repository, androidIdeInfo.resourceJavaPackage);
+ }
+ }
+
+ maybeRefreshJars(missingClassJars, pendingDependencyJarsRefresh);
+ return results;
+ }
+
+ private static VirtualFile findFileByIoFile(File file) {
+ return ApplicationManager.getApplication().isUnitTestMode()
+ ? TempFileSystem.getInstance().findFileByIoFile(file)
+ : LocalFileSystem.getInstance().findFileByIoFile(file);
+ }
+
+ private static void maybeRefreshJars(Collection<File> missingJars, AtomicBoolean pendingRefresh) {
+ // We probably need to refresh the virtual file system to find these files, but we can't refresh
+ // here because we're in a read action. We also can't use the async refreshIoFiles since it
+ // still tries to refresh the IO files synchronously. A global async refresh can't find new
+ // files in the ObjFS since we're not watching it.
+ // We need to do our own asynchronous refresh, and guard it with a flag to prevent the event
+ // queue from overflowing.
+ if (!missingJars.isEmpty() && !pendingRefresh.getAndSet(true)) {
+ ApplicationManager.getApplication()
+ .invokeLater(
+ () -> {
+ LocalFileSystem.getInstance().refreshIoFiles(missingJars);
+ pendingRefresh.set(false);
+ },
+ ModalityState.NON_MODAL);
+ }
+ }
+
+ private static VirtualFile getJarRootForLocalFile(VirtualFile file) {
+ return ApplicationManager.getApplication().isUnitTestMode()
+ ? TempFileSystem.getInstance().findFileByPath(file.getPath() + JarFileSystem.JAR_SEPARATOR)
+ : JarFileSystem.getInstance().getJarRootForLocalFile(file);
+ }
+}
diff --git a/aswb/2.3/tests/integrationtests/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProviderIntegrationTest.java b/aswb/2.3/tests/integrationtests/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProviderIntegrationTest.java
new file mode 100644
index 0000000..05f1ccf
--- /dev/null
+++ b/aswb/2.3/tests/integrationtests/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProviderIntegrationTest.java
@@ -0,0 +1,501 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.sync.model.idea;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import com.android.tools.idea.model.ClassJarProvider;
+import com.android.tools.idea.res.AppResourceRepository;
+import com.android.tools.idea.res.ResourceClassRegistry;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModule;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry;
+import com.google.idea.blaze.base.BlazeIntegrationTestCase;
+import com.google.idea.blaze.base.ideinfo.AndroidIdeInfo;
+import com.google.idea.blaze.base.ideinfo.ArtifactLocation;
+import com.google.idea.blaze.base.ideinfo.JavaIdeInfo;
+import com.google.idea.blaze.base.ideinfo.LibraryArtifact;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.ideinfo.TargetMapBuilder;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.primitives.Kind;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
+import com.intellij.facet.FacetManager;
+import com.intellij.facet.ModifiableFacetModel;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.vfs.VirtualFile;
+import java.io.File;
+import java.io.IOException;
+import java.util.List;
+import org.jetbrains.android.facet.AndroidFacet;
+import org.jetbrains.android.facet.AndroidFacetConfiguration;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Integration test for {@link BlazeClassJarProvider}. */
+@RunWith(JUnit4.class)
+public class BlazeClassJarProviderIntegrationTest extends BlazeIntegrationTestCase {
+ private static final String BLAZE_BIN = "blaze-out/crosstool/bin";
+
+ private Module module;
+ private ClassJarProvider classJarProvider;
+
+ @Before
+ public void doSetup() {
+ module = testFixture.getModule();
+
+ ArtifactLocationDecoder decoder =
+ (location) -> new File("/src", location.getExecutionRootRelativePath());
+
+ mockBlazeProjectDataManager(
+ new BlazeProjectData(
+ 0L, buildTargetMap(), null, null, null, null, decoder, null, null, null));
+ classJarProvider = new BlazeClassJarProvider(getProject());
+ }
+
+ @Test
+ public void testFindModuleClassFile() {
+ createClassesInJars();
+
+ // Make sure we can find classes in the main resource module.
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.main.MainActivity", module))
+ .isEqualTo(
+ fileSystem.findFile(
+ BLAZE_BIN
+ + "/com/google/example/main.jar!"
+ + "/com/google/example/main/MainActivity.class"));
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.main.R", module))
+ .isEqualTo(
+ fileSystem.findFile(
+ BLAZE_BIN
+ + "/com/google/example/main_resources.jar!"
+ + "/com/google/example/main/R.class"));
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.main.R$string", module))
+ .isEqualTo(
+ fileSystem.findFile(
+ BLAZE_BIN
+ + "/com/google/example/main_resources.jar!"
+ + "/com/google/example/main/R$string.class"));
+
+ // And not classes that are missing.
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.main.MissingClass", module))
+ .isNull();
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.main.R$missing", module))
+ .isNull();
+
+ // And not classes in other libraries.
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.java.CustomView", module))
+ .isNull();
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.android_res.R", module))
+ .isNull();
+ assertThat(
+ classJarProvider.findModuleClassFile("com.google.example.android_res.R$style", module))
+ .isNull();
+ assertThat(
+ classJarProvider.findModuleClassFile(
+ "com.google.unrelated.android_res.R$layout", module))
+ .isNull();
+ }
+
+ @Test
+ public void testMissingMainJar() {
+ createClassesInJars();
+
+ ApplicationManager.getApplication()
+ .runWriteAction(
+ () -> {
+ try {
+ // Let's pretend that this hasn't been built yet.
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/main.jar").delete(this);
+ } catch (IOException ignored) {
+ // ignored
+ }
+ });
+ // This hasn't been built yet, and shouldn't be found.
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.main.MainActivity", module))
+ .isNull();
+ // But these should still be found.
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.main.R", module))
+ .isEqualTo(
+ fileSystem.findFile(
+ BLAZE_BIN
+ + "/com/google/example/main_resources.jar!"
+ + "/com/google/example/main/R.class"));
+ assertThat(classJarProvider.findModuleClassFile("com.google.example.main.R$string", module))
+ .isEqualTo(
+ fileSystem.findFile(
+ BLAZE_BIN
+ + "/com/google/example/main_resources.jar!"
+ + "/com/google/example/main/R$string.class"));
+ }
+
+ @Test
+ public void testGetModuleExternalLibraries() {
+ // Need AndroidFact for AppResourceRepository.
+ ApplicationManager.getApplication()
+ .runWriteAction(
+ () -> {
+ ModifiableFacetModel model = FacetManager.getInstance(module).createModifiableModel();
+ model.addFacet(new MockAndroidFacet(module));
+ model.commit();
+ });
+
+ List<VirtualFile> externalLibraries = classJarProvider.getModuleExternalLibraries(module);
+ assertThat(externalLibraries)
+ .containsExactly(
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/android_lib.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/android_res.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/android_res2.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/transitive/android_res.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/java.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/transitive/java.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/shared/java.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/shared2/java.jar"),
+ fileSystem.findFile("com/google/example/import.jar"),
+ fileSystem.findFile("com/google/example/transitive/import.jar"),
+ fileSystem.findFile("com/google/example/transitive/import2.jar"));
+
+ // Make sure we can generate dynamic classes from all resource packages in dependencies.
+ ResourceClassRegistry registry = ResourceClassRegistry.get(getProject());
+ AppResourceRepository repository = AppResourceRepository.getAppResources(module, false);
+ assertThat(repository).isNotNull();
+ assertThat(registry.findClassDefinition("com.google.example.android_res.R", repository))
+ .isNotNull();
+ assertThat(registry.findClassDefinition("com.google.example.android_res.R$string", repository))
+ .isNotNull();
+ assertThat(registry.findClassDefinition("com.google.example.android_res2.R", repository))
+ .isNotNull();
+ assertThat(registry.findClassDefinition("com.google.example.android_res2.R$layout", repository))
+ .isNotNull();
+ assertThat(
+ registry.findClassDefinition("com.google.example.transitive.android_res.R", repository))
+ .isNotNull();
+ assertThat(
+ registry.findClassDefinition(
+ "com.google.example.transitive.android_res.R$style", repository))
+ .isNotNull();
+
+ // And nothing else.
+ assertThat(registry.findClassDefinition("com.google.example.main.MainActivity", repository))
+ .isNull();
+ assertThat(registry.findClassDefinition("com.google.example.android_res.Bogus", repository))
+ .isNull();
+ assertThat(registry.findClassDefinition("com.google.example.main.R", repository)).isNull();
+ assertThat(registry.findClassDefinition("com.google.example.main.R$string", repository))
+ .isNull();
+ assertThat(registry.findClassDefinition("com.google.example.java.CustomView", repository))
+ .isNull();
+ assertThat(registry.findClassDefinition("com.google.unrelated.android_res.R", repository))
+ .isNull();
+ assertThat(
+ registry.findClassDefinition("com.google.unrelated.android_res.R$layout", repository))
+ .isNull();
+ }
+
+ @Test
+ public void testMissingExternalJars() {
+ ApplicationManager.getApplication()
+ .runWriteAction(
+ () -> {
+ try {
+ // Let's pretend that these haven't been built yet.
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/java.jar").delete(this);
+ fileSystem
+ .findFile(BLAZE_BIN + "/com/google/example/android_res2.jar")
+ .delete(this);
+ fileSystem
+ .findFile(BLAZE_BIN + "/com/google/example/shared2/java.jar")
+ .delete(this);
+ } catch (IOException ignored) {
+ // ignored
+ }
+ });
+ List<VirtualFile> externalLibraries = classJarProvider.getModuleExternalLibraries(module);
+ assertThat(externalLibraries)
+ .containsExactly(
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/android_lib.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/android_res.jar"),
+ // This should be missing.
+ // fileSystem.findFile(BLAZE_BIN + "/com/google/example/android_res2.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/transitive/android_res.jar"),
+ // This should be missing.
+ // fileSystem.findFile(BLAZE_BIN + "/com/google/example/java.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/transitive/java.jar"),
+ fileSystem.findFile(BLAZE_BIN + "/com/google/example/shared/java.jar"),
+ // This should be missing.
+ // fileSystem.findFile(BLAZE_BIN + "/com/google/example/shared2/java.jar"),
+ fileSystem.findFile("com/google/example/import.jar"),
+ fileSystem.findFile("com/google/example/transitive/import.jar"),
+ fileSystem.findFile("com/google/example/transitive/import2.jar"));
+ }
+
+ private void createClassesInJars() {
+ fileSystem.createFile(
+ BLAZE_BIN
+ + "/com/google/example/main.jar!"
+ + "/com/google/example/main/MainActivity.class");
+ fileSystem.createFile(
+ BLAZE_BIN + "/com/google/example/main_resources.jar!" + "/com/google/example/main/R.class");
+ fileSystem.createFile(
+ BLAZE_BIN
+ + "/com/google/example/main_resources.jar!"
+ + "/com/google/example/main/R$string.class");
+ fileSystem.createFile(
+ BLAZE_BIN + "/com/google/example/java.jar!" + "/com/google/example/java/CustomView.class");
+ fileSystem.createFile(
+ BLAZE_BIN
+ + "/com/google/example/android_res_resources.jar!"
+ + "/com/google/example/android_res/R.class");
+ fileSystem.createFile(
+ BLAZE_BIN
+ + "/com/google/example/android_res_resources.jar!"
+ + "/com/google/example/android_res/R$style.class");
+ fileSystem.createFile(
+ BLAZE_BIN
+ + "/com/google/unrelated/android_res_resources.jar!"
+ + "/com/google/unrelated/android_res/R$layout.class");
+ }
+
+ private TargetMap buildTargetMap() {
+ Label mainResourceLibrary = new Label("//com/google/example:main");
+ Label androidLibraryDependency = new Label("//com/google/example:android_lib");
+ Label androidResourceDependency = new Label("//com/google/example:android_res");
+ Label androidResourceDependency2 = new Label("//com/google/example:android_res2");
+ Label transitiveResourceDependency = new Label("//com/google/example/transitive:android_res");
+ Label javaDependency = new Label("//com/google/example:java");
+ Label transitiveJavaDependency = new Label("//com/google/example/transitive:java");
+ Label sharedJavaDependency = new Label("//com/google/example/shared:java");
+ Label sharedJavaDependency2 = new Label("//com/google/example/shared2:java");
+ Label importDependency = new Label("//com/google/example:import");
+ Label transitiveImportDependency = new Label("//com/google/example/transitive:import");
+ Label unrelatedJava = new Label("//com/google/unrelated:java");
+ Label unrelatedAndroidLibrary = new Label("//com/google/unrelated:android_lib");
+ Label unrelatedAndroidResource = new Label("//com/google/unrelated:android_res");
+
+ AndroidResourceModuleRegistry registry = new AndroidResourceModuleRegistry();
+ registry.put(
+ module,
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(mainResourceLibrary)).build());
+ // Not using these, but they should be in the registry.
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(androidResourceDependency)).build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(androidResourceDependency2))
+ .build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(transitiveResourceDependency))
+ .build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(unrelatedAndroidResource)).build());
+ registerProjectService(AndroidResourceModuleRegistry.class, registry);
+
+ return TargetMapBuilder.builder()
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(mainResourceLibrary)
+ .setKind(Kind.ANDROID_LIBRARY)
+ .setJavaInfo(
+ javaInfoWithJars(
+ "com/google/example/main.jar", "com/google/example/main_resources.jar"))
+ .setAndroidInfo(
+ androidInfoWithResourceAndJar(
+ "com.google.example.main",
+ "com/google/example/main/res",
+ "com/google/example/main_resources.jar"))
+ .addDependency(androidLibraryDependency)
+ .addDependency(androidResourceDependency)
+ .addDependency(androidResourceDependency2)
+ .addDependency(javaDependency)
+ .addDependency(importDependency))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(androidLibraryDependency)
+ .setKind(Kind.ANDROID_LIBRARY)
+ .setJavaInfo(javaInfoWithJars("com/google/example/android_lib.jar"))
+ .addDependency(transitiveResourceDependency))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(androidResourceDependency)
+ .setKind(Kind.ANDROID_LIBRARY)
+ .setJavaInfo(
+ javaInfoWithJars(
+ "com/google/example/android_res.jar",
+ "com/google/example/android_res_resources.jar"))
+ .setAndroidInfo(
+ androidInfoWithResourceAndJar(
+ "com.google.example.android_res",
+ "com/google/example/android_res/res",
+ "com/google/example/android_res_resources.jar")))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(androidResourceDependency2)
+ .setKind(Kind.ANDROID_LIBRARY)
+ .setJavaInfo(
+ javaInfoWithJars(
+ "com/google/example/android_res2.jar",
+ "com/google/example/android_res2_resources.jar"))
+ .setAndroidInfo(
+ androidInfoWithResourceAndJar(
+ "com.google.example.android_res2",
+ "com/google/example/android_res2/res",
+ "com/google/example/android_res2_resources.jar")))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(transitiveResourceDependency)
+ .setKind(Kind.ANDROID_LIBRARY)
+ .setJavaInfo(
+ javaInfoWithJars(
+ "com/google/example/transitive/android_res.jar",
+ "com/google/example/transitive/android_res_resources.jar"))
+ .setAndroidInfo(
+ androidInfoWithResourceAndJar(
+ "com.google.example.transitive.android_res",
+ "com/google/example/transitive/android_res/res",
+ "com/google/example/transitive/android_res_resources.jar")))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(javaDependency)
+ .setKind(Kind.JAVA_LIBRARY)
+ .setJavaInfo(javaInfoWithJars("com/google/example/java.jar"))
+ .addDependency(transitiveJavaDependency)
+ .addDependency(sharedJavaDependency)
+ .addDependency(sharedJavaDependency2)
+ .addDependency(transitiveImportDependency))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(transitiveJavaDependency)
+ .setKind(Kind.JAVA_LIBRARY)
+ .setJavaInfo(javaInfoWithJars("com/google/example/transitive/java.jar"))
+ .addDependency(sharedJavaDependency)
+ .addDependency(sharedJavaDependency2))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(sharedJavaDependency)
+ .setKind(Kind.JAVA_LIBRARY)
+ .setJavaInfo(javaInfoWithJars("com/google/example/shared/java.jar"))
+ .addDependency(sharedJavaDependency2))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(sharedJavaDependency2)
+ .setKind(Kind.JAVA_LIBRARY)
+ .setJavaInfo(javaInfoWithJars("com/google/example/shared2/java.jar")))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(importDependency)
+ .setKind(Kind.JAVA_IMPORT)
+ .setJavaInfo(javaInfoWithCheckedInJars("com/google/example/import.jar")))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(transitiveImportDependency)
+ .setKind(Kind.JAVA_IMPORT)
+ .setJavaInfo(
+ javaInfoWithCheckedInJars(
+ "com/google/example/transitive/import.jar",
+ "com/google/example/transitive/import2.jar")))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(unrelatedJava)
+ .setKind(Kind.JAVA_LIBRARY)
+ .setJavaInfo(javaInfoWithJars("com/google/unrelated/java.jar")))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(unrelatedAndroidLibrary)
+ .setKind(Kind.ANDROID_LIBRARY)
+ .setJavaInfo(javaInfoWithJars("com/google/unrelated/android_lib.jar")))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(unrelatedAndroidResource)
+ .setKind(Kind.ANDROID_LIBRARY)
+ .setJavaInfo(
+ javaInfoWithJars(
+ "com/google/unrelated/android_res.jar",
+ "com/google/unrelated/android_res_resources.jar"))
+ .setAndroidInfo(
+ androidInfoWithResourceAndJar(
+ "com.google.unrelated.android_res",
+ "com/google/unrelated/android_res/res",
+ "com/google/unrelated/android_res_resources.jar")))
+ .build();
+ }
+
+ private JavaIdeInfo.Builder javaInfoWithJars(String... relativeJarPaths) {
+ JavaIdeInfo.Builder builder = JavaIdeInfo.builder();
+ for (String relativeJarPath : relativeJarPaths) {
+ ArtifactLocation jar =
+ ArtifactLocation.builder()
+ .setRootExecutionPathFragment(BLAZE_BIN)
+ .setRelativePath(relativeJarPath)
+ .setIsSource(false)
+ .build();
+ builder.addJar(LibraryArtifact.builder().setClassJar(jar));
+ fileSystem.createFile(jar.getExecutionRootRelativePath());
+ }
+ return builder;
+ }
+
+ private JavaIdeInfo.Builder javaInfoWithCheckedInJars(String... relativeJarPaths) {
+ JavaIdeInfo.Builder builder = JavaIdeInfo.builder();
+ for (String relativeJarPath : relativeJarPaths) {
+ ArtifactLocation jar =
+ ArtifactLocation.builder().setRelativePath(relativeJarPath).setIsSource(true).build();
+ builder.addJar(LibraryArtifact.builder().setClassJar(jar));
+ fileSystem.createFile(jar.getExecutionRootRelativePath());
+ }
+ return builder;
+ }
+
+ private static AndroidIdeInfo.Builder androidInfoWithResourceAndJar(
+ String javaPackage, String relativeResourcePath, String relativeJarPath) {
+ return AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .setResourceJavaPackage(javaPackage)
+ .addResource(
+ ArtifactLocation.builder()
+ .setRelativePath(relativeResourcePath)
+ .setIsSource(true)
+ .build())
+ .setResourceJar(
+ LibraryArtifact.builder()
+ .setClassJar(
+ // No need to createFile for this one since it should also be in the Java info.
+ ArtifactLocation.builder()
+ .setRootExecutionPathFragment(BLAZE_BIN)
+ .setRelativePath(relativeJarPath)
+ .setIsSource(false)
+ .build()));
+ }
+
+ private static class MockAndroidFacet extends AndroidFacet {
+ public MockAndroidFacet(Module module) {
+ super(module, AndroidFacet.NAME, new AndroidFacetConfiguration());
+ }
+
+ @Override
+ public void initFacet() {
+ // We don't need this, but it causes trouble when it tries looking for project templates.
+ }
+ }
+}
diff --git a/aswb/2.3/tests/unittests/com/google/idea/blaze/android/project/BlazeBuildSystemServiceTest.java b/aswb/2.3/tests/unittests/com/google/idea/blaze/android/project/BlazeBuildSystemServiceTest.java
new file mode 100755
index 0000000..72541b3
--- /dev/null
+++ b/aswb/2.3/tests/unittests/com/google/idea/blaze/android/project/BlazeBuildSystemServiceTest.java
@@ -0,0 +1,263 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.project;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyNoMoreInteractions;
+import static org.mockito.Mockito.when;
+
+import com.android.tools.idea.project.BuildSystemService;
+import com.google.common.collect.Maps;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModule;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.actions.BlazeBuildService;
+import com.google.idea.blaze.base.ideinfo.ArtifactLocation;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.ideinfo.TargetMapBuilder;
+import com.google.idea.blaze.base.lang.buildfile.references.BuildReferenceManager;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.projectview.ProjectViewManager;
+import com.google.idea.blaze.base.projectview.ProjectViewSet;
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.settings.BlazeImportSettings;
+import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
+import com.google.idea.blaze.base.sync.BlazeSyncManager;
+import com.google.idea.blaze.base.sync.BlazeSyncPlugin.ModuleEditor;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
+import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
+import com.intellij.mock.MockModule;
+import com.intellij.mock.MockVirtualFile;
+import com.intellij.openapi.editor.LazyRangeMarkerFactory;
+import com.intellij.openapi.editor.impl.LazyRangeMarkerFactoryImpl;
+import com.intellij.openapi.extensions.ExtensionPoint;
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.fileEditor.FileEditorManager;
+import com.intellij.openapi.fileEditor.OpenFileDescriptor;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.openapi.vfs.ex.temp.TempFileSystem;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import java.io.File;
+import java.util.Map;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+
+/** Test cases for {@link BlazeBuildSystemService}. */
+@RunWith(JUnit4.class)
+public class BlazeBuildSystemServiceTest extends BlazeTestCase {
+ Module module;
+ BuildSystemService service;
+
+ @Override
+ protected void initTest(Container applicationServices, Container projectServices) {
+ module = new MockModule(project, () -> {});
+
+ mockBlazeImportSettings(projectServices); // For Blaze.isBlazeProject.
+ createMocksForBuildProject(applicationServices);
+ createMocksForSyncProject(projectServices);
+ createMocksForAddDependency(applicationServices, projectServices);
+
+ ExtensionPoint<BuildSystemService> extensionPoint =
+ registerExtensionPoint(
+ ExtensionPointName.create("com.android.project.buildSystemService"),
+ BuildSystemService.class);
+ extensionPoint.registerExtension(new BlazeBuildSystemService());
+
+ service = BuildSystemService.getInstance(project);
+ }
+
+ @Test
+ public void testIsBlazeBuildSystemService() {
+ assertThat(service).isInstanceOf(BlazeBuildSystemService.class);
+ }
+
+ @Test
+ public void testBuildProject() {
+ service.buildProject(project);
+ verify(BlazeBuildService.getInstance()).buildProject(project);
+ verifyNoMoreInteractions(BlazeBuildService.getInstance());
+ }
+
+ @Test
+ public void testSyncProject() {
+ service.syncProject(project);
+ verify(BlazeSyncManager.getInstance(project)).incrementalProjectSync();
+ verifyNoMoreInteractions(BlazeSyncManager.getInstance(project));
+ }
+
+ @Test
+ public void testAddDependencyWithBuildTargetPsi() throws Exception {
+ PsiElement buildTargetPsi = mock(PsiElement.class);
+ PsiFile psiFile = mock(PsiFile.class);
+
+ BuildReferenceManager buildReferenceManager = BuildReferenceManager.getInstance(project);
+ when(buildReferenceManager.resolveLabel(new Label("//foo:bar"))).thenReturn(buildTargetPsi);
+ when(buildTargetPsi.getContainingFile()).thenReturn(psiFile);
+ when(buildTargetPsi.getTextOffset()).thenReturn(1337);
+
+ VirtualFile buildFile = TempFileSystem.getInstance().findFileByPath("/foo/BUILD");
+ assertThat(buildFile).isNotNull();
+ when(psiFile.getVirtualFile()).thenReturn(buildFile);
+
+ String dependency = "com.android.foo:bar"; // Doesn't matter.
+
+ service.addDependency(module, dependency);
+
+ ArgumentCaptor<OpenFileDescriptor> descriptorCaptor =
+ ArgumentCaptor.forClass(OpenFileDescriptor.class);
+ verify(FileEditorManager.getInstance(project))
+ .openTextEditor(descriptorCaptor.capture(), eq(true));
+ OpenFileDescriptor descriptor = descriptorCaptor.getValue();
+ assertThat(descriptor.getProject()).isEqualTo(project);
+ assertThat(descriptor.getFile()).isEqualTo(buildFile);
+ assertThat(descriptor.getOffset()).isEqualTo(1337);
+ verifyNoMoreInteractions(FileEditorManager.getInstance(project));
+ }
+
+ @Test
+ public void testAddDependencyWithoutBuildTargetPsi() throws Exception {
+ // Can't find PSI for the target.
+ when(BuildReferenceManager.getInstance(project).resolveLabel(new Label("//foo:bar")))
+ .thenReturn(null);
+
+ VirtualFile buildFile = TempFileSystem.getInstance().findFileByPath("/foo/BUILD");
+ assertThat(buildFile).isNotNull();
+
+ String dependency = "com.android.foo:bar"; // Doesn't matter.
+
+ service.addDependency(module, dependency);
+
+ verify(FileEditorManager.getInstance(project)).openFile(buildFile, true);
+ verifyNoMoreInteractions(FileEditorManager.getInstance(project));
+ }
+
+ private void mockBlazeImportSettings(Container projectServices) {
+ BlazeImportSettingsManager importSettingsManager = new BlazeImportSettingsManager(project);
+ importSettingsManager.setImportSettings(
+ new BlazeImportSettings("", "", "", "", "", Blaze.BuildSystem.Blaze));
+ projectServices.register(BlazeImportSettingsManager.class, importSettingsManager);
+ }
+
+ private static void createMocksForBuildProject(Container applicationServices) {
+ applicationServices.register(BlazeBuildService.class, mock(BlazeBuildService.class));
+ }
+
+ private static void createMocksForSyncProject(Container projectServices) {
+ projectServices.register(ProjectViewManager.class, new MockProjectViewManager());
+ projectServices.register(BlazeSyncManager.class, mock(BlazeSyncManager.class));
+ }
+
+ private void createMocksForAddDependency(
+ Container applicationServices, Container projectServices) {
+ projectServices.register(BlazeProjectDataManager.class, new MockProjectDataManager());
+ projectServices.register(FileEditorManager.class, mock(FileEditorManager.class));
+ projectServices.register(BuildReferenceManager.class, mock(BuildReferenceManager.class));
+ projectServices.register(LazyRangeMarkerFactory.class, mock(LazyRangeMarkerFactoryImpl.class));
+
+ applicationServices.register(TempFileSystem.class, new MockFileSystem("/foo/BUILD"));
+
+ AndroidResourceModuleRegistry moduleRegistry = new AndroidResourceModuleRegistry();
+ moduleRegistry.put(
+ module,
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(new Label("//foo:bar"))).build());
+ projectServices.register(AndroidResourceModuleRegistry.class, moduleRegistry);
+ }
+
+ private static class MockProjectViewManager extends ProjectViewManager {
+ private ProjectViewSet viewSet;
+
+ public MockProjectViewManager() {
+ this.viewSet = ProjectViewSet.builder().build();
+ }
+
+ @Nullable
+ @Override
+ public ProjectViewSet getProjectViewSet() {
+ return viewSet;
+ }
+
+ @Nullable
+ @Override
+ public ProjectViewSet reloadProjectView(
+ BlazeContext context, WorkspacePathResolver workspacePathResolver) {
+ return viewSet;
+ }
+ }
+
+ private static class MockProjectDataManager implements BlazeProjectDataManager {
+ private BlazeProjectData projectData;
+
+ public MockProjectDataManager() {
+ TargetMap targetMap =
+ TargetMapBuilder.builder()
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(new Label("//foo:bar"))
+ .setBuildFile(ArtifactLocation.builder().setRelativePath("foo/BUILD").build())
+ .build())
+ .build();
+ ArtifactLocationDecoder decoder = (location) -> new File("/", location.getRelativePath());
+
+ projectData =
+ new BlazeProjectData(0L, targetMap, null, null, null, null, decoder, null, null, null);
+ }
+
+ @Nullable
+ @Override
+ public BlazeProjectData getBlazeProjectData() {
+ return projectData;
+ }
+
+ @Override
+ public ModuleEditor editModules() {
+ return null;
+ }
+ }
+
+ private static class MockFileSystem extends TempFileSystem {
+ private Map<String, VirtualFile> files;
+
+ public MockFileSystem(String... paths) {
+ files = Maps.newHashMap();
+ for (String path : paths) {
+ files.put(path, new MockVirtualFile(path));
+ }
+ }
+
+ @Override
+ public VirtualFile findFileByPath(String path) {
+ return files.get(path);
+ }
+
+ @Override
+ public VirtualFile findFileByIoFile(File file) {
+ return findFileByPath(file.getPath());
+ }
+ }
+}
diff --git a/aswb/2.3/tests/unittests/com/google/idea/blaze/android/project/BlazeFeatureEnabledServiceTest.java b/aswb/2.3/tests/unittests/com/google/idea/blaze/android/project/BlazeFeatureEnabledServiceTest.java
new file mode 100644
index 0000000..e4fe775
--- /dev/null
+++ b/aswb/2.3/tests/unittests/com/google/idea/blaze/android/project/BlazeFeatureEnabledServiceTest.java
@@ -0,0 +1,158 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.project;
+
+import static com.google.common.truth.Truth.THROW_ASSERTION_ERROR;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import com.android.tools.idea.project.FeatureEnableService;
+import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.android.settings.BlazeAndroidUserSettings;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
+import com.google.idea.blaze.base.settings.BlazeImportSettings;
+import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
+import com.google.idea.blaze.base.settings.BlazeImportSettingsManagerLegacy;
+import com.google.idea.blaze.base.sync.BlazeSyncPlugin.ModuleEditor;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.common.experiments.ExperimentService;
+import com.intellij.openapi.extensions.ExtensionPoint;
+import com.intellij.openapi.extensions.ExtensionPointName;
+import javax.annotation.Nullable;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Test cases for {@link BlazeFeatureEnableService}. */
+@RunWith(JUnit4.class)
+public class BlazeFeatureEnabledServiceTest extends BlazeTestCase {
+ private MockExperimentService experimentService;
+ private BlazeAndroidUserSettings userSettings;
+ private MockBlazeProjectDataManager projectDataManager;
+ private FeatureEnableService featureEnableService;
+
+ @Override
+ protected void initTest(
+ @NotNull Container applicationServices, @NotNull Container projectServices) {
+ super.initTest(applicationServices, projectServices);
+ experimentService = new MockExperimentService();
+ applicationServices.register(ExperimentService.class, experimentService);
+
+ userSettings = new BlazeAndroidUserSettings();
+ applicationServices.register(BlazeAndroidUserSettings.class, userSettings);
+
+ projectDataManager = new MockBlazeProjectDataManager();
+ projectServices.register(BlazeProjectDataManager.class, projectDataManager);
+
+ BlazeImportSettingsManager importSettingsManager = new BlazeImportSettingsManager(project);
+ importSettingsManager.setImportSettings(
+ new BlazeImportSettings(null, null, null, null, null, BuildSystem.Blaze));
+ projectServices.register(BlazeImportSettingsManager.class, importSettingsManager);
+ projectServices.register(
+ BlazeImportSettingsManagerLegacy.class, new BlazeImportSettingsManagerLegacy(project));
+
+ ExtensionPoint<FeatureEnableService> extensionPoint =
+ registerExtensionPoint(
+ ExtensionPointName.create("com.android.project.featureEnableService"),
+ FeatureEnableService.class);
+ extensionPoint.registerExtension(new BlazeFeatureEnableService());
+
+ featureEnableService = FeatureEnableService.getInstance(project);
+ }
+
+ @Test
+ public void testIsBlazeFeatureEnableService() {
+ assertThat(featureEnableService).isInstanceOf(BlazeFeatureEnableService.class);
+ }
+
+ @Test
+ public void testIsNotBlazeFeatureEnableService() {
+ BlazeImportSettingsManager.getInstance(project).loadState(null);
+ assertThat(FeatureEnableService.getInstance(project))
+ .isNotInstanceOf(BlazeFeatureEnableService.class);
+ }
+
+ @Test
+ public void testGetLayoutEditorEnabled() {
+ for (boolean experimentEnabled : ImmutableList.of(true, false)) {
+ for (boolean settingEnabled : ImmutableList.of(true, false)) {
+ for (boolean projectDataReady : ImmutableList.of(true, false)) {
+ userSettings.setUseLayoutEditor(settingEnabled);
+ experimentService.setEnableLayoutEditor(experimentEnabled);
+ projectDataManager.setBlazeProjectData(
+ projectDataReady ? mock(BlazeProjectData.class) : null);
+ assertThat(featureEnableService.isLayoutEditorEnabled(project))
+ .isEqualTo(settingEnabled && experimentEnabled && projectDataReady);
+ }
+ }
+ }
+ }
+
+ private static class MockBlazeProjectDataManager implements BlazeProjectDataManager {
+ private BlazeProjectData blazeProjectData;
+
+ public void setBlazeProjectData(BlazeProjectData blazeProjectData) {
+ this.blazeProjectData = blazeProjectData;
+ }
+
+ @Nullable
+ @Override
+ public BlazeProjectData getBlazeProjectData() {
+ return blazeProjectData;
+ }
+
+ @Override
+ public ModuleEditor editModules() {
+ return null;
+ }
+ }
+
+ private static class MockExperimentService implements ExperimentService {
+ private boolean enableLayoutEditor;
+
+ public void setEnableLayoutEditor(boolean enableLayoutEditor) {
+ this.enableLayoutEditor = enableLayoutEditor;
+ }
+
+ @Override
+ public boolean getExperiment(String key, boolean defaultValue) {
+ assertThat(key).isEqualTo("enable.layout.editor");
+ return enableLayoutEditor;
+ }
+
+ @Nullable
+ @Override
+ public String getExperimentString(String key, @Nullable String defaultValue) {
+ THROW_ASSERTION_ERROR.fail("Should not be called.");
+ return null;
+ }
+
+ @Override
+ public int getExperimentInt(String key, int defaultValue) {
+ THROW_ASSERTION_ERROR.fail("Should not be called.");
+ return 0;
+ }
+
+ @Override
+ public void startExperimentScope() {}
+
+ @Override
+ public void endExperimentScope() {}
+ }
+}
diff --git a/aswb/2.3/tests/unittests/com/google/idea/blaze/android/rendering/BlazeRenderErrorContributorTest.java b/aswb/2.3/tests/unittests/com/google/idea/blaze/android/rendering/BlazeRenderErrorContributorTest.java
new file mode 100644
index 0000000..5bbeec6
--- /dev/null
+++ b/aswb/2.3/tests/unittests/com/google/idea/blaze/android/rendering/BlazeRenderErrorContributorTest.java
@@ -0,0 +1,768 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.rendering;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import com.android.tools.idea.rendering.RenderErrorContributor;
+import com.android.tools.idea.rendering.RenderErrorModelFactory;
+import com.android.tools.idea.rendering.RenderResult;
+import com.android.tools.idea.rendering.errors.ui.RenderErrorModel;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.common.collect.Iterables;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModule;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.ideinfo.AndroidIdeInfo;
+import com.google.idea.blaze.base.ideinfo.ArtifactLocation;
+import com.google.idea.blaze.base.ideinfo.JavaIdeInfo;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.ideinfo.TargetMapBuilder;
+import com.google.idea.blaze.base.lang.buildfile.references.BuildReferenceManager;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
+import com.google.idea.blaze.base.settings.BlazeImportSettings;
+import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
+import com.google.idea.blaze.base.settings.BlazeImportSettingsManagerLegacy;
+import com.google.idea.blaze.base.sync.BlazeSyncPlugin.ModuleEditor;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
+import com.google.idea.blaze.base.targetmaps.SourceToTargetMap;
+import com.google.idea.blaze.base.targetmaps.TransitiveDependencyMap;
+import com.intellij.mock.MockModule;
+import com.intellij.mock.MockPsiFile;
+import com.intellij.mock.MockPsiManager;
+import com.intellij.mock.MockVirtualFile;
+import com.intellij.openapi.extensions.ExtensionPoint;
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.fileTypes.FileTypeManager;
+import com.intellij.openapi.fileTypes.MockFileTypeManager;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleUtilCore;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.vfs.VfsUtilCore;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.PsiManager;
+import com.intellij.psi.impl.JavaPsiFacadeImpl;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.search.ProjectScopeBuilder;
+import com.intellij.psi.search.ProjectScopeBuilderImpl;
+import com.intellij.psi.util.PsiUtil.NullPsiClass;
+import java.io.File;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link BlazeRenderErrorContributor}. */
+@RunWith(JUnit4.class)
+public class BlazeRenderErrorContributorTest extends BlazeTestCase {
+ private static final String BLAZE_BIN = "blaze-out/crosstool/bin";
+ private static final String GENERATED_RESOURCES_ERROR = "Generated resources";
+ private static final String NON_STANDARD_MANIFEST_NAME_ERROR = "Non-standard manifest name";
+ private static final String MISSING_CLASS_DEPENDENCIES_ERROR = "Missing class dependencies";
+
+ private Module module;
+ private MockBlazeProjectDataManager projectDataManager;
+ private BlazeRenderErrorContributor.BlazeProvider provider;
+
+ @Override
+ protected void initTest(Container applicationServices, Container projectServices) {
+ super.initTest(applicationServices, projectServices);
+ applicationServices.register(FileTypeManager.class, new MockFileTypeManager());
+
+ projectServices.register(BuildReferenceManager.class, new MockBuildReferenceManager(project));
+ projectServices.register(TransitiveDependencyMap.class, new TransitiveDependencyMap(project));
+ projectServices.register(ProjectScopeBuilder.class, new ProjectScopeBuilderImpl(project));
+ projectServices.register(
+ AndroidResourceModuleRegistry.class, new AndroidResourceModuleRegistry());
+
+ BlazeImportSettingsManager importSettingsManager = new BlazeImportSettingsManager(project);
+ BlazeImportSettings settings = new BlazeImportSettings("", "", "", "", "", BuildSystem.Blaze);
+ importSettingsManager.setImportSettings(settings);
+ projectServices.register(BlazeImportSettingsManager.class, importSettingsManager);
+ projectServices.register(
+ BlazeImportSettingsManagerLegacy.class, new BlazeImportSettingsManagerLegacy(project));
+
+ createPsiClassesAndSourceToTargetMap(projectServices);
+
+ projectDataManager = new MockBlazeProjectDataManager();
+ projectServices.register(BlazeProjectDataManager.class, projectDataManager);
+
+ ExtensionPoint<RenderErrorContributor.Provider> extensionPoint =
+ registerExtensionPoint(
+ ExtensionPointName.create("com.android.rendering.renderErrorContributor"),
+ RenderErrorContributor.Provider.class);
+ extensionPoint.registerExtension(new RenderErrorContributor.Provider());
+ extensionPoint.registerExtension(new BlazeRenderErrorContributor.BlazeProvider());
+
+ module = new MockModule(project, () -> {});
+
+ // For the isApplicable tests.
+ provider = new BlazeRenderErrorContributor.BlazeProvider();
+ }
+
+ @Test
+ public void testProviderIsApplicable() {
+ assertThat(provider.isApplicable(project)).isTrue();
+ }
+
+ @Test
+ public void testProviderNotApplicableIfNotBlaze() {
+ BlazeImportSettingsManager.getInstance(project).loadState(null);
+ assertThat(provider.isApplicable(project)).isFalse();
+ }
+
+ @Test
+ public void testNoIssuesIfNoErrors() {
+ PsiFile file = new MockPsiFile(new MockPsiManager(project));
+ file.putUserData(ModuleUtilCore.KEY_MODULE, module);
+ RenderResult result = RenderResult.createBlank(file);
+ RenderErrorModel errorModel = RenderErrorModelFactory.createErrorModel(result, null);
+ assertThat(errorModel.getIssues()).isEmpty();
+ }
+
+ @Test
+ public void testNoBlazeIssuesIfNoRelatedErrors() {
+ RenderErrorModel errorModel = createRenderErrorModelWithBrokenClasses();
+ errorModel
+ .getIssues()
+ .forEach(
+ issue ->
+ assertThat(issue.getSummary())
+ .isNoneOf(
+ GENERATED_RESOURCES_ERROR,
+ NON_STANDARD_MANIFEST_NAME_ERROR,
+ MISSING_CLASS_DEPENDENCIES_ERROR));
+ }
+
+ @Test
+ public void testReportGeneratedResources() {
+ createTargetMapWithGeneratedResources();
+ RenderErrorModel errorModel = createRenderErrorModelWithBrokenClasses();
+
+ RenderErrorModel.Issue generatedResourcesIssue =
+ Iterables.getOnlyElement(
+ errorModel
+ .getIssues()
+ .stream()
+ .filter(issue -> issue.getSummary().equals(GENERATED_RESOURCES_ERROR))
+ .collect(Collectors.toList()));
+
+ assertThat(generatedResourcesIssue.getHtmlContent())
+ .isEqualTo(
+ "Generated resources will not be discovered by the IDE:"
+ + "<DL>"
+ + "<DD>-&NBSP;"
+ + "com/google/example/dependency/generated/res "
+ + "from <A HREF=\"file:///src/com/google/example/dependency/BUILD\">"
+ + "//com/google/example:generated</A>"
+ + "<DD>-&NBSP;"
+ + "com/google/example/main/generated/res "
+ + "from <A HREF=\"file:///src/com/google/example/main/BUILD\">"
+ + "//com/google/example:main</A>"
+ + "<DD>-&NBSP;"
+ + "com/google/example/transitive/generated/one/res "
+ + "from <A HREF=\"file:///src/com/google/example/transitive/BUILD\">"
+ + "//com/google/example/transitive:generated</A>"
+ + "<DD>-&NBSP;"
+ + "com/google/example/transitive/generated/two/res "
+ + "from <A HREF=\"file:///src/com/google/example/transitive/BUILD\">"
+ + "//com/google/example/transitive:generated</A>"
+ + "</DL>"
+ + "Please avoid using generated resources, then "
+ + "<A HREF=\"action:sync\">sync the project</A> and "
+ + "<A HREF=\"refreshRender\">refresh the layout</A>.");
+ }
+
+ @Test
+ public void testReportNonStandardAndroidManifestName() {
+ createTargetMapWithNonStandardAndroidManifestName();
+ RenderErrorModel errorModel = createRenderErrorModelWithBrokenClasses();
+
+ RenderErrorModel.Issue nonStandardManifestNameIssue =
+ Iterables.getOnlyElement(
+ errorModel
+ .getIssues()
+ .stream()
+ .filter(issue -> issue.getSummary().equals(NON_STANDARD_MANIFEST_NAME_ERROR))
+ .collect(Collectors.toList()));
+
+ assertThat(nonStandardManifestNameIssue.getHtmlContent())
+ .isEqualTo(
+ "<A HREF=\"file:///src/com/google/example/main/BUILD\">"
+ + "//com/google/example:main</A> "
+ + "uses a non-standard name for the Android manifest: "
+ + "<A HREF=\"file:///src/com/google/example/main/WeirdManifest.xml\">"
+ + "WeirdManifest.xml</A>"
+ + "<BR/>"
+ + "Please rename it to AndroidManifest.xml, then "
+ + "<A HREF=\"action:sync\">sync the project</A> and "
+ + "<A HREF=\"refreshRender\">refresh the layout</A>.");
+ }
+
+ @Test
+ public void testNoReportNonStandardAndroidManifestNameInDependency() {
+ createTargetMapWithNonStandardAndroidManifestNameInDependency();
+ RenderErrorModel errorModel = createRenderErrorModelWithBrokenClasses();
+
+ errorModel
+ .getIssues()
+ .forEach(
+ issue -> assertThat(issue.getSummary()).isNotEqualTo(NON_STANDARD_MANIFEST_NAME_ERROR));
+ }
+
+ @Test
+ public void testReportMissingClassDependencies() {
+ createTargetMapWithMissingClassDependency();
+ RenderErrorModel errorModel =
+ createRenderErrorModelWithMissingClasses(
+ "com.google.example.independent.LibraryView",
+ "com.google.example.independent.LibraryView2",
+ "com.google.example.independent.Library2View",
+ "com.google.example.dependent.LibraryView",
+ "com.google.example.ResourceView");
+
+ RenderErrorModel.Issue missingClassDependenciesIssue =
+ Iterables.getOnlyElement(
+ errorModel
+ .getIssues()
+ .stream()
+ .filter(issue -> issue.getSummary().equals(MISSING_CLASS_DEPENDENCIES_ERROR))
+ .collect(Collectors.toList()));
+
+ assertThat(missingClassDependenciesIssue.getHtmlContent())
+ .isEqualTo(
+ "<A HREF=\"file:///src/com/google/example/BUILD\">"
+ + "//com/google/example:resources</A> "
+ + "contains resource files that reference these classes:"
+ + "<DL>"
+ + "<DD>-&NBSP;"
+ + "<A HREF=\"openClass:com.google.example.independent.Library2View\">"
+ + "com.google.example.independent.Library2View</A> "
+ + "from <A HREF=\"file:///src/com/google/example/BUILD\">"
+ + "//com/google/example/independent:library2</A> "
+ + "<DD>-&NBSP;"
+ + "<A HREF=\"openClass:com.google.example.independent.LibraryView\">"
+ + "com.google.example.independent.LibraryView</A> "
+ + "from <A HREF=\"file:///src/com/google/example/BUILD\">"
+ + "//com/google/example/independent:library</A> "
+ + "<DD>-&NBSP;"
+ + "<A HREF=\"openClass:com.google.example.independent.LibraryView2\">"
+ + "com.google.example.independent.LibraryView2</A> "
+ + "from <A HREF=\"file:///src/com/google/example/BUILD\">"
+ + "//com/google/example/independent:library</A> "
+ + "</DL>"
+ + "Please fix your dependencies so that "
+ + "<A HREF=\"file:///src/com/google/example/BUILD\">"
+ + "//com/google/example:resources</A> "
+ + "correctly depends on these classes, then "
+ + "<A HREF=\"action:sync\">sync the project</A> and "
+ + "<A HREF=\"refreshRender\">refresh the layout</A>."
+ + "<BR/>"
+ + "<BR/>"
+ + "<B>NOTE: blaze can still build with the incorrect dependencies "
+ + "due to the way it handles resources, "
+ + "but the layout editor needs them to be correct.</B>");
+ }
+
+ @Test
+ public void testNoReportMissingClassDependenciesIfClassInSameTarget() {
+ createTargetMapWithMissingClassDependency();
+ RenderErrorModel errorModel =
+ createRenderErrorModelWithMissingClasses("com.google.example.ResourceView");
+
+ errorModel
+ .getIssues()
+ .forEach(
+ issue -> assertThat(issue.getSummary()).isNotEqualTo(MISSING_CLASS_DEPENDENCIES_ERROR));
+ }
+
+ @Test
+ public void testNoReportMissingClassDependenciesIfClassInDependency() {
+ createTargetMapWithMissingClassDependency();
+ RenderErrorModel errorModel =
+ createRenderErrorModelWithMissingClasses("com.google.example.dependent.LibraryView");
+
+ errorModel
+ .getIssues()
+ .forEach(
+ issue -> assertThat(issue.getSummary()).isNotEqualTo(MISSING_CLASS_DEPENDENCIES_ERROR));
+ }
+
+ private RenderErrorModel createRenderErrorModelWithBrokenClasses() {
+ PsiFile file = new MockPsiFile(new MockPsiManager(project));
+ file.putUserData(ModuleUtilCore.KEY_MODULE, module);
+ RenderResult result = RenderResult.createBlank(file);
+ result
+ .getLogger()
+ .addBrokenClass("com.google.example.CustomView", new Exception("resource not found"));
+ return RenderErrorModelFactory.createErrorModel(result, null);
+ }
+
+ private RenderErrorModel createRenderErrorModelWithMissingClasses(String... classNames) {
+ PsiFile file = new MockPsiFile(new MockPsiManager(project));
+ file.putUserData(ModuleUtilCore.KEY_MODULE, module);
+ RenderResult result = RenderResult.createBlank(file);
+ for (String className : classNames) {
+ result.getLogger().addMissingClass(className);
+ }
+ return RenderErrorModelFactory.createErrorModel(result, null);
+ }
+
+ private static ArtifactLocation artifact(String relativePath, boolean isSource) {
+ return ArtifactLocation.builder()
+ .setIsSource(isSource)
+ .setRootExecutionPathFragment(isSource ? "" : BLAZE_BIN)
+ .setRelativePath(relativePath)
+ .build();
+ }
+
+ private void createTargetMapWithGeneratedResources() {
+ Label mainResourcesTarget = new Label("//com/google/example:main");
+ Label dependencyGeneratedResourceTarget = new Label("//com/google/example:generated");
+ Label dependencySourceResourceTarget = new Label("//com/google/example:source");
+ Label transitiveGeneratedResourcesTarget =
+ new Label("//com/google/example/transitive:generated");
+ Label transitiveSourceResourceTarget = new Label("//com/google/example/transitive:source");
+ Label unrelatedGeneratedResourceTarget = new Label("//com/google/unrelated:generated");
+ Label unrelatedSourceResourceTarget = new Label("//com/google/unrelated:source");
+
+ ArtifactLocation mainGeneratedResource =
+ artifact("com/google/example/main/generated/res", false);
+ ArtifactLocation mainSourceResource = artifact("com/google/example/main/source/res", true);
+ ArtifactLocation dependencyGeneratedResource =
+ artifact("com/google/example/dependency/generated/res", false);
+ ArtifactLocation dependencySourceResource =
+ artifact("com/google/example/dependency/source/res", true);
+ ArtifactLocation transitiveGeneratedResourceOne =
+ artifact("com/google/example/transitive/generated/one/res", false);
+ ArtifactLocation transitiveGeneratedResourceTwo =
+ artifact("com/google/example/transitive/generated/two/res", false);
+ ArtifactLocation transitiveSourceResource =
+ artifact("com/google/example/transitive/source/res", true);
+ ArtifactLocation unrelatedGeneratedResource =
+ artifact("com/google/unrelated/generated/res", false);
+ ArtifactLocation unrelatedSourceResource = artifact("com/google/unrelated/source/res", true);
+
+ ArtifactLocation mainBuildFile = artifact("com/google/example/main/BUILD", true);
+ ArtifactLocation dependencyBuildFile = artifact("com/google/example/dependency/BUILD", true);
+ ArtifactLocation transitiveBuildFile = artifact("com/google/example/transitive/BUILD", true);
+ ArtifactLocation unrelatedBuildFile = artifact("com/google/unrelated/BUILD", true);
+
+ AndroidResourceModuleRegistry registry = AndroidResourceModuleRegistry.getInstance(project);
+ registry.put(
+ module,
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(mainResourcesTarget))
+ // .addResource(mainGeneratedResource) // Dropped.
+ .addResource(mainSourceResource)
+ .addTransitiveResourceDependency(dependencyGeneratedResourceTarget)
+ .addTransitiveResource(dependencyGeneratedResource)
+ .addTransitiveResourceDependency(dependencySourceResourceTarget)
+ .addTransitiveResource(dependencySourceResource)
+ .addTransitiveResourceDependency(transitiveGeneratedResourcesTarget)
+ .addTransitiveResource(transitiveGeneratedResourceOne)
+ .addTransitiveResource(transitiveGeneratedResourceTwo)
+ .addTransitiveResourceDependency(transitiveSourceResourceTarget)
+ .addTransitiveResource(transitiveSourceResource)
+ .build());
+ // Not using these, but they should be in the registry.
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(dependencyGeneratedResourceTarget))
+ // .addResource(dependencyGeneratedResource) // Dropped.
+ .addTransitiveResourceDependency(transitiveSourceResourceTarget)
+ .addTransitiveResource(transitiveSourceResource)
+ .build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(dependencySourceResourceTarget))
+ .addResource(dependencySourceResource)
+ .addTransitiveResourceDependency(transitiveGeneratedResourcesTarget)
+ .addTransitiveResource(transitiveGeneratedResourceOne)
+ .addTransitiveResource(transitiveGeneratedResourceTwo)
+ .build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(transitiveGeneratedResourcesTarget))
+ // .addResource(transitiveGeneratedResourceOne) // Dropped.
+ // .addResource(transitiveGeneratedResourceTwo) // Dropped.
+ .build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(transitiveSourceResourceTarget))
+ .addResource(transitiveSourceResource)
+ .build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(unrelatedGeneratedResourceTarget))
+ // .addResource(unrelatedGeneratedResource) // Dropped.
+ .build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(unrelatedSourceResourceTarget))
+ .addResource(unrelatedSourceResource)
+ .build());
+
+ TargetMap targetMap =
+ TargetMapBuilder.builder()
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(mainResourcesTarget)
+ .setBuildFile(mainBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .addResource(mainGeneratedResource)
+ .addResource(mainSourceResource))
+ .addDependency(dependencyGeneratedResourceTarget)
+ .addDependency(dependencySourceResourceTarget))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(dependencyGeneratedResourceTarget)
+ .setBuildFile(dependencyBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .addResource(dependencyGeneratedResource))
+ .addDependency(transitiveSourceResourceTarget))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(dependencySourceResourceTarget)
+ .setBuildFile(dependencyBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .addResource(dependencySourceResource))
+ .addDependency(transitiveGeneratedResourcesTarget))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(transitiveGeneratedResourcesTarget)
+ .setBuildFile(transitiveBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .addResource(transitiveGeneratedResourceOne)
+ .addResource(transitiveGeneratedResourceTwo)))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(transitiveSourceResourceTarget)
+ .setBuildFile(transitiveBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .addResource(transitiveSourceResource)))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(unrelatedGeneratedResourceTarget)
+ .setBuildFile(unrelatedBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .addResource(unrelatedGeneratedResource)))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(unrelatedSourceResourceTarget)
+ .setBuildFile(unrelatedBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .addResource(unrelatedSourceResource)))
+ .build();
+
+ projectDataManager.setTargetMap(targetMap);
+ }
+
+ private void createTargetMapWithNonStandardAndroidManifestName() {
+ Label mainResourceTarget = new Label("//com/google/example:main");
+
+ ArtifactLocation mainManifest = artifact("com/google/example/main/WeirdManifest.xml", true);
+ ArtifactLocation mainResource = artifact("com/google/example/main/res", true);
+ ArtifactLocation mainBuildFile = artifact("com/google/example/main/BUILD", true);
+
+ AndroidResourceModuleRegistry registry = AndroidResourceModuleRegistry.getInstance(project);
+ registry.put(
+ module,
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(mainResourceTarget))
+ .addResource(mainResource)
+ .build());
+
+ TargetMap targetMap =
+ TargetMapBuilder.builder()
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(mainResourceTarget)
+ .setBuildFile(mainBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .setManifestFile(mainManifest)
+ .addResource(mainResource)))
+ .build();
+
+ projectDataManager.setTargetMap(targetMap);
+ }
+
+ private void createTargetMapWithNonStandardAndroidManifestNameInDependency() {
+ Label mainResourceTarget = new Label("//com/google/example:main");
+ Label dependencyResourceTarget = new Label("//com/google/example:dependency");
+
+ ArtifactLocation mainManifest = artifact("com/google/example/main/AndroidManifest.xml", true);
+ ArtifactLocation mainResource = artifact("com/google/example/main/res", true);
+ ArtifactLocation mainBuildFile = artifact("com/google/example/main/BUILD", true);
+
+ ArtifactLocation dependencyManifest =
+ artifact("com/google/example/dependency/MyManifest.xml", true);
+ ArtifactLocation dependencyResource = artifact("com/google/example/dependency/res", true);
+ ArtifactLocation dependencyBuildFile = artifact("com/google/example/dependency/BUILD", true);
+
+ AndroidResourceModuleRegistry registry = AndroidResourceModuleRegistry.getInstance(project);
+ registry.put(
+ module,
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(mainResourceTarget))
+ .addResource(mainResource)
+ .addTransitiveResourceDependency(dependencyResourceTarget)
+ .addTransitiveResource(dependencyResource)
+ .build());
+ registry.put(
+ mock(Module.class),
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(dependencyResourceTarget))
+ .addResource(dependencyResource)
+ .build());
+
+ TargetMap targetMap =
+ TargetMapBuilder.builder()
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(mainResourceTarget)
+ .setBuildFile(mainBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .setManifestFile(mainManifest)
+ .addResource(mainResource)))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(dependencyResourceTarget)
+ .setBuildFile(dependencyBuildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .setManifestFile(dependencyManifest)
+ .addResource(dependencyResource)))
+ .build();
+
+ projectDataManager.setTargetMap(targetMap);
+ }
+
+ private void createTargetMapWithMissingClassDependency() {
+ Label parentTarget = new Label("//com/google/example:app");
+ Label independentLibraryTarget = new Label("//com/google/example/independent:library");
+ Label independentLibrary2Target = new Label("//com/google/example/independent:library2");
+ Label dependentLibraryTarget = new Label("//com/google/example/dependent:library");
+ Label resourcesTarget = new Label("//com/google/example:resources");
+
+ ArtifactLocation manifest = artifact("com/google/example/AndroidManifest.xml", true);
+ ArtifactLocation resources = artifact("com/google/example/res", true);
+ ArtifactLocation buildFile = artifact("com/google/example/BUILD", true);
+
+ AndroidResourceModuleRegistry registry = AndroidResourceModuleRegistry.getInstance(project);
+ registry.put(
+ module,
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(resourcesTarget))
+ .addResource(resources)
+ .build());
+
+ TargetMap targetMap =
+ TargetMapBuilder.builder()
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(parentTarget)
+ .setBuildFile(buildFile)
+ .addDependency(independentLibraryTarget)
+ .addDependency(resourcesTarget))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(independentLibraryTarget)
+ .setBuildFile(buildFile)
+ .setJavaInfo(JavaIdeInfo.builder())
+ .addDependency(independentLibrary2Target))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(independentLibrary2Target)
+ .setBuildFile(buildFile)
+ .setJavaInfo(JavaIdeInfo.builder()))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(resourcesTarget)
+ .setBuildFile(buildFile)
+ .setAndroidInfo(
+ AndroidIdeInfo.builder()
+ .setGenerateResourceClass(true)
+ .setManifestFile(manifest)
+ .addResource(resources))
+ .addDependency(dependentLibraryTarget))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(dependentLibraryTarget)
+ .setBuildFile(buildFile)
+ .setJavaInfo(JavaIdeInfo.builder()))
+ .build();
+
+ projectDataManager.setTargetMap(targetMap);
+ }
+
+ private void createPsiClassesAndSourceToTargetMap(Container projectServices) {
+ PsiManager psiManager = new MockPsiManager(project);
+
+ VirtualFile independentLibraryView =
+ new MockVirtualFile("src/com/google/example/independent/LibraryView.java");
+ VirtualFile independentLibraryView2 =
+ new MockVirtualFile("src/com/google/example/independent/LibraryView2.java");
+ VirtualFile independentLibrary2View =
+ new MockVirtualFile("src/com/google/example/independent/Library2View.java");
+ VirtualFile dependentLibraryView =
+ new MockVirtualFile("src/com/google/example/dependent/LibraryView.java");
+ VirtualFile resourceView = new MockVirtualFile("src/com/google/example/ResourceView.java");
+
+ ImmutableMap<String, PsiClass> classes =
+ ImmutableMap.of(
+ "com.google.example.independent.LibraryView",
+ new MockPsiClass(psiManager, independentLibraryView),
+ "com.google.example.independent.LibraryView2",
+ new MockPsiClass(psiManager, independentLibraryView2),
+ "com.google.example.independent.Library2View",
+ new MockPsiClass(psiManager, independentLibrary2View),
+ "com.google.example.dependent.LibraryView",
+ new MockPsiClass(psiManager, dependentLibraryView),
+ "com.google.example.ResourceView",
+ new MockPsiClass(psiManager, resourceView));
+
+ ImmutableMap<File, TargetKey> sourceToTarget =
+ ImmutableMap.of(
+ VfsUtilCore.virtualToIoFile(independentLibraryView),
+ TargetKey.forPlainTarget(new Label("//com/google/example/independent:library")),
+ VfsUtilCore.virtualToIoFile(independentLibraryView2),
+ TargetKey.forPlainTarget(new Label("//com/google/example/independent:library")),
+ VfsUtilCore.virtualToIoFile(independentLibrary2View),
+ TargetKey.forPlainTarget(new Label("//com/google/example/independent:library2")),
+ VfsUtilCore.virtualToIoFile(dependentLibraryView),
+ TargetKey.forPlainTarget(new Label("//com/google/example/dependent:library")),
+ VfsUtilCore.virtualToIoFile(resourceView),
+ TargetKey.forPlainTarget(new Label("//com/google/example:resources")));
+
+ projectServices.register(
+ JavaPsiFacade.class, new MockJavaPsiFacade(project, psiManager, classes));
+ projectServices.register(SourceToTargetMap.class, new MockSourceToTargetMap(sourceToTarget));
+ }
+
+ private static class MockBlazeProjectDataManager implements BlazeProjectDataManager {
+ private BlazeProjectData blazeProjectData;
+
+ public void setTargetMap(TargetMap targetMap) {
+ ArtifactLocationDecoder decoder =
+ (location) -> new File("/src", location.getExecutionRootRelativePath());
+ this.blazeProjectData =
+ new BlazeProjectData(0L, targetMap, null, null, null, null, decoder, null, null, null);
+ }
+
+ @Nullable
+ @Override
+ public BlazeProjectData getBlazeProjectData() {
+ return blazeProjectData;
+ }
+
+ @Override
+ public ModuleEditor editModules() {
+ return null;
+ }
+ }
+
+ private static class MockBuildReferenceManager extends BuildReferenceManager {
+ public MockBuildReferenceManager(Project project) {
+ super(project);
+ }
+
+ @Nullable
+ @Override
+ public PsiElement resolveLabel(Label label) {
+ return null;
+ }
+ }
+
+ private static class MockPsiClass extends NullPsiClass {
+ private PsiFile psiFile;
+
+ public MockPsiClass(PsiManager psiManager, VirtualFile virtualFile) {
+ psiFile =
+ new MockPsiFile(psiManager) {
+ @Override
+ public VirtualFile getVirtualFile() {
+ return virtualFile;
+ }
+ };
+ }
+
+ @Override
+ public PsiFile getContainingFile() {
+ return psiFile;
+ }
+ }
+
+ private static class MockJavaPsiFacade extends JavaPsiFacadeImpl {
+ private ImmutableMap<String, PsiClass> classes;
+
+ public MockJavaPsiFacade(
+ Project project, PsiManager psiManager, ImmutableMap<String, PsiClass> classes) {
+ super(project, psiManager, null, null);
+ this.classes = classes;
+ }
+
+ @Override
+ public PsiClass findClass(String qualifiedName, GlobalSearchScope scope) {
+ return classes.get(qualifiedName);
+ }
+ }
+
+ private static class MockSourceToTargetMap implements SourceToTargetMap {
+ private ImmutableMap<File, TargetKey> sourceToTarget;
+
+ public MockSourceToTargetMap(ImmutableMap<File, TargetKey> sourceToTarget) {
+ this.sourceToTarget = sourceToTarget;
+ }
+
+ @Override
+ public ImmutableCollection<Label> getTargetsToBuildForSourceFile(File file) {
+ return ImmutableList.of();
+ }
+
+ @Override
+ public ImmutableCollection<TargetKey> getRulesForSourceFile(File file) {
+ return ImmutableList.of(sourceToTarget.get(file));
+ }
+ }
+}
diff --git a/aswb/2.3/tests/unittests/com/google/idea/blaze/android/run/testrecorder/BlazeConfigurationsTest.java b/aswb/2.3/tests/unittests/com/google/idea/blaze/android/run/testrecorder/BlazeConfigurationsTest.java
new file mode 100644
index 0000000..86c20cf
--- /dev/null
+++ b/aswb/2.3/tests/unittests/com/google/idea/blaze/android/run/testrecorder/BlazeConfigurationsTest.java
@@ -0,0 +1,292 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.run.testrecorder;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.android.tools.idea.run.editor.AndroidDebugger;
+import com.android.tools.idea.run.editor.AndroidJavaDebugger;
+import com.android.tools.idea.run.editor.DeployTargetProvider;
+import com.android.tools.idea.run.editor.ShowChooserTargetProvider;
+import com.google.common.base.Predicate;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.gct.testrecorder.run.TestRecorderRunConfigurationProxy;
+import com.google.gct.testrecorder.run.TestRecorderRunConfigurationProxyProvider;
+import com.google.gct.testrecorder.ui.TestRecorderAction;
+import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationHandler;
+import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationHandlerProvider;
+import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationState;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.bazel.BuildSystemProvider;
+import com.google.idea.blaze.base.bazel.WorkspaceRootProvider;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.lang.buildfile.language.semantics.RuleDefinition;
+import com.google.idea.blaze.base.model.BlazeVersionData;
+import com.google.idea.blaze.base.model.primitives.Kind;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
+import com.google.idea.blaze.base.run.BlazeBeforeRunTaskProvider;
+import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
+import com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType;
+import com.google.idea.blaze.base.run.confighandler.BlazeCommandRunConfigurationHandler;
+import com.google.idea.blaze.base.run.confighandler.BlazeCommandRunConfigurationHandlerProvider;
+import com.google.idea.blaze.base.run.targetfinder.TargetFinder;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
+import com.google.idea.blaze.base.settings.BlazeImportSettings;
+import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
+import com.intellij.execution.BeforeRunTaskProvider;
+import com.intellij.execution.RunManager;
+import com.intellij.execution.RunManagerEx;
+import com.intellij.execution.configurations.ConfigurationType;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.impl.RunManagerImpl;
+import com.intellij.ide.util.ProjectPropertiesComponentImpl;
+import com.intellij.mock.MockModule;
+import com.intellij.mock.MockProject;
+import com.intellij.openapi.extensions.ExtensionPoint;
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.extensions.impl.ExtensionPointImpl;
+import com.intellij.openapi.extensions.impl.ExtensionsAreaImpl;
+import com.intellij.openapi.fileTypes.FileNameMatcher;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
+import java.io.File;
+import java.util.List;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Test cases for {@link TestRecorderBlazeCommandRunConfiguration}. */
+@RunWith(JUnit4.class)
+public class BlazeConfigurationsTest extends BlazeTestCase {
+
+ @Override
+ protected void initTest(Container applicationServices, Container projectServices) {
+ super.initTest(applicationServices, projectServices);
+
+ mockBlazeImportSettings(projectServices);
+ applicationServices.register(TargetFinder.class, new MockTargetFinder());
+
+ ExtensionPoint<ConfigurationType> configurationTypeExtensionPoint =
+ registerExtensionPoint(ConfigurationType.CONFIGURATION_TYPE_EP, ConfigurationType.class);
+ configurationTypeExtensionPoint.registerExtension(new BlazeCommandRunConfigurationType());
+
+ ExtensionPoint<BlazeCommandRunConfigurationHandlerProvider> handlerProviderExtensionPoint =
+ registerExtensionPoint(
+ BlazeCommandRunConfigurationHandlerProvider.EP_NAME,
+ BlazeCommandRunConfigurationHandlerProvider.class);
+ handlerProviderExtensionPoint.registerExtension(
+ new MockBlazeAndroidBinaryRunConfigurationHandlerProvider());
+
+ ExtensionPoint<BuildSystemProvider> buildSystemProviderExtensionPoint =
+ registerExtensionPoint(BuildSystemProvider.EP_NAME, BuildSystemProvider.class);
+ buildSystemProviderExtensionPoint.registerExtension(new MockBuildSystemProvider());
+
+ ExtensionPoint<DeployTargetProvider> deployTargetProviderExtensionPoint =
+ registerExtensionPoint(
+ ExtensionPointName.create("com.android.run.deployTargetProvider"),
+ DeployTargetProvider.class);
+ deployTargetProviderExtensionPoint.registerExtension(new ShowChooserTargetProvider());
+
+ ExtensionPoint<AndroidDebugger> androidDebuggerExtensionPoint =
+ registerExtensionPoint(AndroidDebugger.EP_NAME, AndroidDebugger.class);
+ androidDebuggerExtensionPoint.registerExtension(new AndroidJavaDebugger());
+
+ ExtensionPoint<BeforeRunTaskProvider> beforeRunTaskProviderExtensionPoint =
+ registerExtensionPoint(
+ ExtensionPointName.create("com.intellij.stepsBeforeRunProvider"),
+ BeforeRunTaskProvider.class);
+ ((ExtensionsAreaImpl) Extensions.getArea(project))
+ .registerExtensionPoint((ExtensionPointImpl) beforeRunTaskProviderExtensionPoint);
+ beforeRunTaskProviderExtensionPoint.registerExtension(new BlazeBeforeRunTaskProvider());
+
+ ExtensionPoint<TestRecorderRunConfigurationProxyProvider>
+ testRecorderRunConfigurationProxyProviderExtensionPoint =
+ registerExtensionPoint(
+ ExtensionPointName.create(
+ "com.google.gct.testrecorder.run.testRecorderRunConfigurationProxyProvider"),
+ TestRecorderRunConfigurationProxyProvider.class);
+ testRecorderRunConfigurationProxyProviderExtensionPoint.registerExtension(
+ new TestRecorderBlazeCommandRunConfigurationProxyProvider());
+
+ ((MockProject) project)
+ .addComponent(
+ RunManager.class, new RunManagerImpl(project, new ProjectPropertiesComponentImpl()));
+ }
+
+ @Test
+ public void testSuitableRunConfigurations() {
+ addConfigurations();
+
+ List<RunConfiguration> allConfigurations =
+ RunManagerEx.getInstanceEx(project).getAllConfigurationsList();
+ assertThat(allConfigurations.size()).isEqualTo(2);
+
+ List<RunConfiguration> suitableConfigurations =
+ TestRecorderAction.getSuitableRunConfigurations(project);
+ assertThat(suitableConfigurations.size()).isEqualTo(1);
+ assertThat(suitableConfigurations.get(0).getName()).isEqualTo("AndroidBinaryConfiguration");
+ }
+
+ @Test
+ public void testLaunchActivityClass() {
+ BlazeCommandRunConfiguration blazeConfiguration =
+ BlazeCommandRunConfigurationType.getInstance()
+ .getFactory()
+ .createTemplateConfiguration(project);
+ blazeConfiguration.setTarget(new Label("//label:android_binary_rule"));
+ BlazeAndroidBinaryRunConfigurationState configurationState =
+ ((BlazeAndroidBinaryRunConfigurationHandler) blazeConfiguration.getHandler()).getState();
+ configurationState.setMode(BlazeAndroidBinaryRunConfigurationState.LAUNCH_SPECIFIC_ACTIVITY);
+ configurationState.setActivityClass("MyAppMainActivity");
+
+ TestRecorderRunConfigurationProxy proxy =
+ TestRecorderRunConfigurationProxy.getInstance(blazeConfiguration);
+ assertThat(proxy).isNotNull();
+ assertThat(proxy.getLaunchActivityClass()).isEqualTo("MyAppMainActivity");
+ }
+
+ private void mockBlazeImportSettings(Container projectServices) {
+ BlazeImportSettingsManager importSettingsManager = new BlazeImportSettingsManager(project);
+ importSettingsManager.setImportSettings(
+ new BlazeImportSettings("", "", "", "", "", Blaze.BuildSystem.Blaze));
+ projectServices.register(BlazeImportSettingsManager.class, importSettingsManager);
+ }
+
+ private void addConfigurations() {
+ RunManagerImpl runManager = (RunManagerImpl) RunManagerEx.getInstanceEx(project);
+ BlazeCommandRunConfigurationType.BlazeCommandRunConfigurationFactory configurationFactory =
+ BlazeCommandRunConfigurationType.getInstance().getFactory();
+
+ BlazeCommandRunConfiguration blazeAndroidBinaryConfiguration =
+ configurationFactory.createTemplateConfiguration(project);
+ blazeAndroidBinaryConfiguration.setName("AndroidBinaryConfiguration");
+ blazeAndroidBinaryConfiguration.setTarget(new Label("//label:android_binary_rule"));
+
+ BlazeCommandRunConfiguration blazeAndroidTestConfiguration =
+ configurationFactory.createTemplateConfiguration(project);
+ blazeAndroidTestConfiguration.setName("AndroidTestConfiguration");
+ blazeAndroidTestConfiguration.setTarget(new Label("//label:android_test_rule"));
+
+ runManager.addConfiguration(
+ runManager.createConfiguration(blazeAndroidBinaryConfiguration, configurationFactory),
+ true);
+ runManager.addConfiguration(
+ runManager.createConfiguration(blazeAndroidTestConfiguration, configurationFactory), true);
+ }
+
+ private class MockTargetFinder extends TargetFinder {
+ @Override
+ public List<TargetIdeInfo> findTargets(Project project, Predicate<TargetIdeInfo> predicate) {
+ return null;
+ }
+
+ @Override
+ public TargetIdeInfo targetForLabel(Project project, final Label label) {
+ TargetIdeInfo.Builder builder = TargetIdeInfo.builder().setLabel(label);
+ if (label.equals(new Label("//label:android_binary_rule"))) {
+ builder.setKind(Kind.ANDROID_BINARY);
+ } else if (label.equals(new Label("//label:android_test_rule"))) {
+ builder.setKind(Kind.ANDROID_TEST);
+ }
+ return builder.build();
+ }
+ }
+
+ private class MockBlazeAndroidBinaryRunConfigurationHandlerProvider
+ extends BlazeAndroidBinaryRunConfigurationHandlerProvider {
+ @Override
+ public boolean canHandleKind(Kind kind) {
+ return true;
+ }
+
+ @Override
+ public BlazeCommandRunConfigurationHandler createHandler(BlazeCommandRunConfiguration config) {
+ return new MockBlazeAndroidBinaryRunConfigurationHandler(config);
+ }
+ }
+
+ private class MockBlazeAndroidBinaryRunConfigurationHandler
+ extends BlazeAndroidBinaryRunConfigurationHandler {
+ private final MockModule mockModule;
+
+ MockBlazeAndroidBinaryRunConfigurationHandler(BlazeCommandRunConfiguration configuration) {
+ super(configuration);
+ mockModule = new MockModule(project, () -> {});
+ }
+
+ @Nullable
+ @Override
+ public Module getModule() {
+ Label label = getLabel();
+ if (label != null && label.equals(new Label("//label:android_binary_rule"))) {
+ return mockModule;
+ }
+
+ return null;
+ }
+ }
+
+ private class MockBuildSystemProvider implements BuildSystemProvider {
+ @Override
+ public Blaze.BuildSystem buildSystem() {
+ return Blaze.BuildSystem.Blaze;
+ }
+
+ @Override
+ public WorkspaceRootProvider getWorkspaceRootProvider() {
+ return null;
+ }
+
+ @Override
+ public ImmutableList<String> buildArtifactDirectories(WorkspaceRoot root) {
+ return null;
+ }
+
+ @Nullable
+ @Override
+ public String getRuleDocumentationUrl(RuleDefinition rule) {
+ return null;
+ }
+
+ @Override
+ public boolean isBuildFile(String fileName) {
+ return false;
+ }
+
+ @Nullable
+ @Override
+ public File findBuildFileInDirectory(File directory) {
+ return null;
+ }
+
+ @Override
+ public FileNameMatcher buildFileMatcher() {
+ return null;
+ }
+
+ @Override
+ public void populateBlazeVersionData(
+ BuildSystem buildSystem,
+ WorkspaceRoot workspaceRoot,
+ ImmutableMap<String, String> blazeInfo,
+ BlazeVersionData.Builder builder) {}
+ }
+}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/InstantRunExperiment.java b/aswb/2.3/tests/utils/integration/com/google/idea/blaze/android/BlazeAndroidIntegrationTestCase.java
similarity index 65%
rename from aswb/src/com/google/idea/blaze/android/run/binary/instantrun/InstantRunExperiment.java
rename to aswb/2.3/tests/utils/integration/com/google/idea/blaze/android/BlazeAndroidIntegrationTestCase.java
index 148b1d9..74459a0 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/InstantRunExperiment.java
+++ b/aswb/2.3/tests/utils/integration/com/google/idea/blaze/android/BlazeAndroidIntegrationTestCase.java
@@ -13,12 +13,10 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package com.google.idea.blaze.android.run.binary.instantrun;
-import com.google.idea.common.experiments.BoolExperiment;
+package com.google.idea.blaze.android;
-/** Holds the instant run experiment */
-public class InstantRunExperiment {
- public static final BoolExperiment INSTANT_RUN_ENABLED =
- new BoolExperiment("instant.run.enabled", false);
-}
+import com.google.idea.blaze.base.BlazeIntegrationTestCase;
+
+/** Compatibility test class for Blaze Android integration tests. */
+public abstract class BlazeAndroidIntegrationTestCase extends BlazeIntegrationTestCase {}
diff --git a/aswb/BUILD b/aswb/BUILD
index f3cfd00..16fc99b 100644
--- a/aswb/BUILD
+++ b/aswb/BUILD
@@ -11,6 +11,7 @@
"stamped_plugin_xml",
)
load("//:version.bzl", "VERSION")
+load("//intellij_platform_sdk:build_defs.bzl", "select_for_plugin_api")
merged_plugin_xml(
name = "merged_plugin_xml_common",
@@ -19,7 +20,12 @@
"//base:plugin_xml",
"//cpp:plugin_xml",
"//java:plugin_xml",
- ],
+ ] + select_for_plugin_api({
+ # TODO(chaorenl): remove when 2.2 is obsolete
+ "android-studio-145.1617.8": [],
+ "android-studio-2.3.0.3": ["2.3/src/META-INF/aswb_beta.xml"],
+ "android-studio-2.3.0.4": ["2.3/src/META-INF/aswb_beta.xml"],
+ }),
visibility = [
"//visibility:public",
],
@@ -45,7 +51,12 @@
java_library(
name = "aswb_lib",
- srcs = glob(["src/**/*.java"]),
+ srcs = glob(["src/**/*.java"]) + select_for_plugin_api({
+ # TODO(chaorenl): remove when 2.2 is obsolete
+ "android-studio-145.1617.8": glob(["2.2/src/**/*.java"]),
+ "android-studio-2.3.0.3": glob(["2.3/src/**/*.java"]),
+ "android-studio-2.3.0.4": glob(["2.3/src/**/*.java"]),
+ }),
resources = glob(["resources/**/*"]),
visibility = [
"//visibility:public",
@@ -61,10 +72,15 @@
],
)
+# TODO(chaorenl): remove when 2.2 is obsolete
java_library(
name = "integration_test_utils",
testonly = 1,
- srcs = glob(["tests/utils/integration/**/*.java"]),
+ srcs = select_for_plugin_api({
+ "android-studio-145.1617.8": glob(["2.2/tests/utils/integration/**/*.java"]),
+ "android-studio-2.3.0.3": glob(["2.3/tests/utils/integration/**/*.java"]),
+ "android-studio-2.3.0.4": glob(["2.3/tests/utils/integration/**/*.java"]),
+ }),
deps = [
"//base",
"//base:integration_test_utils",
@@ -83,7 +99,12 @@
intellij_unit_test_suite(
name = "unit_tests",
- srcs = glob(["tests/unittests/**/*.java"]),
+ srcs = glob(["tests/unittests/**/*.java"]) + select_for_plugin_api({
+ # TODO(chaorenl): remove when 2.2 is obsolete
+ "android-studio-145.1617.8": [],
+ "android-studio-2.3.0.3": glob(["2.3/tests/unittests/**/*.java"]),
+ "android-studio-2.3.0.4": glob(["2.3/tests/unittests/**/*.java"]),
+ }),
test_package_root = "com.google.idea.blaze.android",
deps = [
":aswb_lib",
@@ -101,7 +122,12 @@
intellij_integration_test_suite(
name = "integration_tests",
- srcs = glob(["tests/integrationtests/**/*.java"]),
+ srcs = glob(["tests/integrationtests/**/*.java"]) + select_for_plugin_api({
+ # TODO(chaorenl): remove when 2.2 is obsolete
+ "android-studio-145.1617.8": [],
+ "android-studio-2.3.0.3": glob(["2.3/tests/integrationtests/**/*.java"]),
+ "android-studio-2.3.0.4": glob(["2.3/tests/integrationtests/**/*.java"]),
+ }),
platform_prefix = "AndroidStudio",
required_plugins = "com.google.idea.bazel.aswb",
test_package_root = "com.google.idea.blaze.android",
diff --git a/aswb/aswb.bazelproject b/aswb/aswb.bazelproject
index 34cbb52..c2f7d36 100644
--- a/aswb/aswb.bazelproject
+++ b/aswb/aswb.bazelproject
@@ -4,6 +4,8 @@
-plugin_dev
-clwb
-cpp/src/com/google/idea/blaze/cpp/versioned/v162
+ # TODO(chaorenl): remove when 2.2 is obsolete.
+ -aswb/2.3
targets:
//aswb:aswb_bazel
diff --git a/aswb/src/META-INF/aswb.xml b/aswb/src/META-INF/aswb.xml
index ca22494..48f701d 100644
--- a/aswb/src/META-INF/aswb.xml
+++ b/aswb/src/META-INF/aswb.xml
@@ -18,7 +18,8 @@
<depends>com.intellij.modules.androidstudio</depends>
<depends>org.jetbrains.android</depends>
- <depends>com.android.tools.idea.updater</depends>
+ <!-- TODO(chaorenl): remove when 2.2 is obsolete -->
+ <depends optional="true">com.android.tools.idea.updater</depends>
<extensions defaultExtensionNs="com.intellij">
<java.elementFinder implementation="com.google.idea.blaze.android.resources.AndroidResourceClassFinder"
@@ -31,14 +32,14 @@
<runConfigurationProducer
implementation="com.google.idea.blaze.android.run.test.BlazeAndroidTestMethodRunConfigurationProducer"
order="first"/>
- <configurationType implementation="com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationType"/>
- <configurationType implementation="com.google.idea.blaze.android.run.test.BlazeAndroidTestRunConfigurationType"/>
<programRunner implementation="com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryProgramRunner" order="first"/>
<executor implementation="com.google.idea.blaze.android.run.binary.mobileinstall.IncrementalInstallRunExecutor" order="last"/>
<executor implementation="com.google.idea.blaze.android.run.binary.mobileinstall.IncrementalInstallDebugExecutor" order="last"/>
<applicationService serviceInterface="com.google.idea.blaze.base.plugin.BlazePluginId"
serviceImplementation="com.google.idea.blaze.android.plugin.AswbPlugin"/>
<projectService serviceImplementation="com.google.idea.blaze.android.manifest.ManifestParser"/>
+ <projectService serviceImplementation="com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry"/>
+ <applicationService serviceImplementation="com.google.idea.blaze.android.settings.BlazeAndroidUserSettings"/>
</extensions>
<extensions defaultExtensionNs="org.jetbrains.android.actions">
@@ -88,4 +89,4 @@
</component>
</application-components>
-</idea-plugin>
\ No newline at end of file
+</idea-plugin>
diff --git a/aswb/src/com/google/idea/blaze/android/projectview/AndroidSdkPlatformSection.java b/aswb/src/com/google/idea/blaze/android/projectview/AndroidSdkPlatformSection.java
index 056f692..0c14f79 100644
--- a/aswb/src/com/google/idea/blaze/android/projectview/AndroidSdkPlatformSection.java
+++ b/aswb/src/com/google/idea/blaze/android/projectview/AndroidSdkPlatformSection.java
@@ -15,6 +15,7 @@
*/
package com.google.idea.blaze.android.projectview;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidSdkUtils;
import com.google.idea.blaze.android.sync.sdk.AndroidSdkFromProjectView;
import com.google.idea.blaze.base.projectview.ProjectView;
import com.google.idea.blaze.base.projectview.parser.ParseContext;
@@ -28,7 +29,6 @@
import com.intellij.openapi.projectRoots.Sdk;
import com.intellij.openapi.util.text.StringUtil;
import java.util.Collection;
-import org.jetbrains.android.sdk.AndroidSdkUtils;
import org.jetbrains.annotations.Nullable;
/** Allows manual override of the android sdk. */
diff --git a/aswb/src/com/google/idea/blaze/android/run/BlazeAndroidRunConfigurationCommonState.java b/aswb/src/com/google/idea/blaze/android/run/BlazeAndroidRunConfigurationCommonState.java
index 5bd0c77..6926023 100644
--- a/aswb/src/com/google/idea/blaze/android/run/BlazeAndroidRunConfigurationCommonState.java
+++ b/aswb/src/com/google/idea/blaze/android/run/BlazeAndroidRunConfigurationCommonState.java
@@ -215,5 +215,11 @@
}
return UiUtil.createBox(result);
}
+
+ @Override
+ public void setComponentEnabled(boolean enabled) {
+ userFlagsEditor.setComponentEnabled(enabled);
+ enableNativeDebuggingCheckBox.setEnabled(enabled);
+ }
}
}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryNormalBuildRunContext.java b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryNormalBuildRunContext.java
index b90cc35..5351213 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryNormalBuildRunContext.java
+++ b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryNormalBuildRunContext.java
@@ -33,6 +33,7 @@
import com.android.tools.idea.run.util.ProcessHandlerLaunchStatus;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.Futures;
+import com.google.idea.blaze.android.compatibility.Compatibility;
import com.google.idea.blaze.android.run.deployinfo.BlazeAndroidDeployInfo;
import com.google.idea.blaze.android.run.deployinfo.BlazeApkProvider;
import com.google.idea.blaze.android.run.runner.BlazeAndroidDeviceSelector;
@@ -167,14 +168,22 @@
@Nullable
@Override
+ @SuppressWarnings("unchecked")
public DebugConnectorTask getDebuggerTask(
AndroidDebugger androidDebugger,
AndroidDebuggerState androidDebuggerState,
- Set<String> packageIds)
+ Set<String> packageIds,
+ boolean monitorRemoteProcess)
throws ExecutionException {
- //noinspection unchecked
- return androidDebugger.getConnectDebuggerTask(
- env, null, packageIds, facet, androidDebuggerState, runConfiguration.getType().getId());
+ return Compatibility.getConnectDebuggerTask(
+ androidDebugger,
+ env,
+ null,
+ packageIds,
+ facet,
+ androidDebuggerState,
+ runConfiguration.getType().getId(),
+ monitorRemoteProcess);
}
@Nullable
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationHandler.java b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationHandler.java
index a70da60..3b222f7 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationHandler.java
+++ b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationHandler.java
@@ -15,16 +15,13 @@
*/
package com.google.idea.blaze.android.run.binary;
-import com.android.sdklib.AndroidVersion;
-import com.android.tools.idea.fd.InstantRunManager;
-import com.android.tools.idea.run.AndroidSessionInfo;
+import com.android.annotations.VisibleForTesting;
import com.android.tools.idea.run.ValidationError;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.idea.blaze.android.run.BlazeAndroidRunConfigurationCommonState;
import com.google.idea.blaze.android.run.BlazeAndroidRunConfigurationHandler;
import com.google.idea.blaze.android.run.BlazeAndroidRunConfigurationValidationUtil;
-import com.google.idea.blaze.android.run.binary.instantrun.BlazeAndroidBinaryInstantRunContext;
import com.google.idea.blaze.android.run.binary.mobileinstall.BlazeAndroidBinaryMobileInstallRunContext;
import com.google.idea.blaze.android.run.runner.BlazeAndroidRunConfigurationRunner;
import com.google.idea.blaze.android.run.runner.BlazeAndroidRunContext;
@@ -42,15 +39,12 @@
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.configurations.RuntimeConfigurationException;
-import com.intellij.execution.executors.DefaultRunExecutor;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
-import icons.AndroidIcons;
import java.util.List;
import javax.swing.Icon;
import org.jetbrains.android.facet.AndroidFacet;
-import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
@@ -63,7 +57,8 @@
private final BlazeCommandRunConfiguration configuration;
private final BlazeAndroidBinaryRunConfigurationState configState;
- BlazeAndroidBinaryRunConfigurationHandler(BlazeCommandRunConfiguration configuration) {
+ @VisibleForTesting
+ protected BlazeAndroidBinaryRunConfigurationHandler(BlazeCommandRunConfiguration configuration) {
this.configuration = configuration;
configState =
new BlazeAndroidBinaryRunConfigurationState(
@@ -91,7 +86,7 @@
}
@Nullable
- private Module getModule() {
+ public Module getModule() {
Label target = getLabel();
return target != null
? BlazeAndroidProjectStructureSyncer.ensureRunConfigurationModule(
@@ -125,10 +120,7 @@
AndroidFacet facet,
ExecutionEnvironment env,
ImmutableList<String> buildFlags) {
- if (configState.instantRun()) {
- return new BlazeAndroidBinaryInstantRunContext(
- project, facet, configuration, env, configState, getLabel(), buildFlags);
- } else if (configState.mobileInstall()) {
+ if (configState.mobileInstall()) {
return new BlazeAndroidBinaryMobileInstallRunContext(
project, facet, configuration, env, configState, getLabel(), buildFlags);
} else {
@@ -187,27 +179,7 @@
@Override
@Nullable
- public Icon getExecutorIcon(@NotNull RunConfiguration configuration, @NotNull Executor executor) {
- if (!configState.instantRun()) {
- return null;
- }
-
- AndroidSessionInfo info =
- AndroidSessionInfo.findOldSession(
- this.configuration.getProject(), null, this.configuration.getUniqueID());
- if (info == null || !info.isInstantRun() || !info.getExecutorId().equals(executor.getId())) {
- return null;
- }
-
- // Make sure instant run is supported on the relevant device, if found.
- AndroidVersion androidVersion =
- InstantRunManager.getMinDeviceApiLevel(info.getProcessHandler());
- if (!InstantRunManager.isInstantRunCapableDeviceVersion(androidVersion)) {
- return null;
- }
-
- return executor instanceof DefaultRunExecutor
- ? AndroidIcons.RunIcons.Replay
- : AndroidIcons.RunIcons.DebugReattach;
+ public Icon getExecutorIcon(RunConfiguration configuration, Executor executor) {
+ return null;
}
}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationState.java b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationState.java
index 6557f8b..cb368d4 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationState.java
+++ b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationState.java
@@ -42,12 +42,10 @@
private static final String MOBILE_INSTALL_ATTR = "blaze-mobile-install";
private static final String USE_SPLIT_APKS_IF_POSSIBLE = "use-split-apks-if-possible";
- private static final String INSTANT_RUN_ATTR = "instant-run";
private static final String WORK_PROFILE_ATTR = "use-work-profile-if-present";
private static final String USER_ID_ATTR = "user-id";
private boolean mobileInstall = false;
private boolean useSplitApksIfPossible = false;
- private boolean instantRun = false;
private boolean useWorkProfileIfPresent = false;
private Integer userId;
@@ -85,14 +83,6 @@
this.useSplitApksIfPossible = useSplitApksIfPossible;
}
- boolean instantRun() {
- return instantRun;
- }
-
- void setInstantRun(boolean instantRun) {
- this.instantRun = instantRun;
- }
-
public boolean useWorkProfileIfPresent() {
return useWorkProfileIfPresent;
}
@@ -156,7 +146,6 @@
setMobileInstall(Boolean.parseBoolean(element.getAttributeValue(MOBILE_INSTALL_ATTR)));
setUseSplitApksIfPossible(
Boolean.parseBoolean(element.getAttributeValue(USE_SPLIT_APKS_IF_POSSIBLE)));
- setInstantRun(Boolean.parseBoolean(element.getAttributeValue(INSTANT_RUN_ATTR)));
setUseWorkProfileIfPresent(Boolean.parseBoolean(element.getAttributeValue(WORK_PROFILE_ATTR)));
String userIdString = element.getAttributeValue(USER_ID_ATTR);
@@ -196,7 +185,6 @@
element.setAttribute(MODE, mode);
element.setAttribute(MOBILE_INSTALL_ATTR, Boolean.toString(mobileInstall));
element.setAttribute(USE_SPLIT_APKS_IF_POSSIBLE, Boolean.toString(useSplitApksIfPossible));
- element.setAttribute(INSTANT_RUN_ATTR, Boolean.toString(instantRun));
element.setAttribute(WORK_PROFILE_ATTR, Boolean.toString(useWorkProfileIfPresent));
if (userId != null) {
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationStateEditor.java b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationStateEditor.java
index c7fbff6..8ce6279 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationStateEditor.java
+++ b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationStateEditor.java
@@ -16,7 +16,6 @@
package com.google.idea.blaze.android.run.binary;
import com.android.tools.idea.run.activity.ActivityLocatorUtils;
-import com.google.idea.blaze.android.run.binary.instantrun.InstantRunExperiment;
import com.google.idea.blaze.base.run.state.RunConfigurationState;
import com.google.idea.blaze.base.run.state.RunConfigurationStateEditor;
import com.google.idea.blaze.base.ui.IntegerTextField;
@@ -75,11 +74,12 @@
private JRadioButton launchCustomButton;
private JCheckBox mobileInstallCheckBox;
private JCheckBox splitApksCheckBox;
- private JCheckBox instantRunCheckBox;
private JCheckBox useWorkProfileIfPresentCheckBox;
private JLabel userIdLabel;
private IntegerTextField userIdField;
+ private boolean componentEnabled = true;
+
BlazeAndroidBinaryRunConfigurationStateEditor(
RunConfigurationStateEditor commonStateEditor, Project project) {
this.commonStateEditor = commonStateEditor;
@@ -126,34 +126,15 @@
}
}
});
- ActionListener listener = e -> activityField.setEnabled(launchCustomButton.isSelected());
+ ActionListener listener = e -> updateEnabledState();
launchCustomButton.addActionListener(listener);
launchDefaultButton.addActionListener(listener);
launchNothingButton.addActionListener(listener);
- instantRunCheckBox.setVisible(InstantRunExperiment.INSTANT_RUN_ENABLED.getValue());
-
- /* Only one of mobile-install and instant run can be selected at any one time */
- mobileInstallCheckBox.addActionListener(
- e -> {
- if (mobileInstallCheckBox.isSelected()) {
- instantRunCheckBox.setSelected(false);
- }
- });
- instantRunCheckBox.addActionListener(
- e -> {
- if (instantRunCheckBox.isSelected()) {
- mobileInstallCheckBox.setSelected(false);
- }
- });
-
mobileInstallCheckBox.addActionListener(
e -> splitApksCheckBox.setVisible(mobileInstallCheckBox.isSelected()));
- useWorkProfileIfPresentCheckBox.addActionListener(
- e -> {
- setUserIdEnabled(!useWorkProfileIfPresentCheckBox.isSelected());
- });
+ useWorkProfileIfPresentCheckBox.addActionListener(e -> updateEnabledState());
}
@Override
@@ -170,24 +151,18 @@
} else {
launchNothingButton.setSelected(true);
}
- activityField.setEnabled(launchSpecificActivity);
if (launchSpecificActivity) {
activityField.getChildComponent().setText(state.getActivityClass());
}
mobileInstallCheckBox.setSelected(state.mobileInstall());
splitApksCheckBox.setSelected(state.useSplitApksIfPossible());
- instantRunCheckBox.setSelected(state.instantRun());
useWorkProfileIfPresentCheckBox.setSelected(state.useWorkProfileIfPresent());
userIdField.setValue(state.getUserId());
- setUserIdEnabled(!state.useWorkProfileIfPresent());
splitApksCheckBox.setVisible(state.mobileInstall());
- }
- private void setUserIdEnabled(boolean enabled) {
- userIdLabel.setEnabled(enabled);
- userIdField.setEnabled(enabled);
+ updateEnabledState();
}
@Override
@@ -207,7 +182,6 @@
}
state.setMobileInstall(mobileInstallCheckBox.isSelected());
state.setUseSplitApksIfPossible(splitApksCheckBox.isSelected());
- state.setInstantRun(instantRunCheckBox.isSelected());
state.setUseWorkProfileIfPresent(useWorkProfileIfPresentCheckBox.isSelected());
}
@@ -216,6 +190,26 @@
return UiUtil.createBox(commonStateEditor.createComponent(), panel);
}
+ private void updateEnabledState() {
+ boolean useWorkProfile = useWorkProfileIfPresentCheckBox.isSelected();
+ userIdLabel.setEnabled(componentEnabled && !useWorkProfile);
+ userIdField.setEnabled(componentEnabled && !useWorkProfile);
+ commonStateEditor.setComponentEnabled(componentEnabled);
+ activityField.setEnabled(componentEnabled && launchCustomButton.isSelected());
+ launchNothingButton.setEnabled(componentEnabled);
+ launchDefaultButton.setEnabled(componentEnabled);
+ launchCustomButton.setEnabled(componentEnabled);
+ mobileInstallCheckBox.setEnabled(componentEnabled);
+ splitApksCheckBox.setEnabled(componentEnabled);
+ useWorkProfileIfPresentCheckBox.setEnabled(componentEnabled);
+ }
+
+ @Override
+ public void setComponentEnabled(boolean enabled) {
+ componentEnabled = enabled;
+ updateEnabledState();
+ }
+
private void createUIComponents(Project project) {
final EditorTextField editorTextField =
new LanguageTextField(PlainTextLanguage.INSTANCE, project, "") {
@@ -465,24 +459,6 @@
null,
0,
false));
- instantRunCheckBox = new JCheckBox();
- instantRunCheckBox.setText(" Use InstantRun");
- panel.add(
- instantRunCheckBox,
- new GridConstraints(
- 2,
- 0,
- 1,
- 2,
- GridConstraints.ANCHOR_WEST,
- GridConstraints.FILL_NONE,
- GridConstraints.SIZEPOLICY_CAN_SHRINK | GridConstraints.SIZEPOLICY_CAN_GROW,
- GridConstraints.SIZEPOLICY_FIXED,
- null,
- null,
- null,
- 0,
- false));
ButtonGroup buttonGroup;
buttonGroup = new ButtonGroup();
buttonGroup.add(launchDefaultButton);
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationType.java b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationType.java
deleted file mode 100644
index bfc5a02..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationType.java
+++ /dev/null
@@ -1,125 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.binary;
-
-import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
-import com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType;
-import com.google.idea.blaze.base.settings.Blaze;
-import com.intellij.execution.BeforeRunTask;
-import com.intellij.execution.configurations.ConfigurationFactory;
-import com.intellij.execution.configurations.ConfigurationType;
-import com.intellij.execution.configurations.ConfigurationTypeUtil;
-import com.intellij.execution.configurations.UnknownConfigurationType;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Key;
-import icons.AndroidIcons;
-import javax.swing.Icon;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A type for Android application run configurations adapted specifically to run android_binary
- * targets.
- *
- * @deprecated See {@link com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType}. Retained
- * in 1.9 for legacy purposes, to allow existing BlazeAndroidBinaryRunConfigurations to be
- * updated to BlazeCommandRunConfigurations. Intended to be removed in 2.1.
- */
-// Hack: extend UnknownConfigurationType to completely hide it in the Run/Debug Configurations UI.
-@Deprecated
-public class BlazeAndroidBinaryRunConfigurationType extends UnknownConfigurationType {
- private final BlazeAndroidBinaryRunConfigurationFactory factory =
- new BlazeAndroidBinaryRunConfigurationFactory(this);
-
- static class BlazeAndroidBinaryRunConfigurationFactory extends ConfigurationFactory {
-
- protected BlazeAndroidBinaryRunConfigurationFactory(@NotNull ConfigurationType type) {
- super(type);
- }
-
- @Override
- public String getName() {
- // Used to look up this ConfigurationFactory.
- // Preserve value so legacy configurations can be loaded.
- return Blaze.defaultBuildSystemName() + " Android Binary";
- }
-
- @Override
- @NotNull
- public BlazeCommandRunConfiguration createTemplateConfiguration(@NotNull Project project) {
- // Create a BlazeCommandRunConfiguration instead, to update legacy configurations.
- return BlazeCommandRunConfigurationType.getInstance()
- .getFactory()
- .createTemplateConfiguration(project);
- }
-
- @Override
- public boolean canConfigurationBeSingleton() {
- return false;
- }
-
- @Override
- public boolean isApplicable(@NotNull Project project) {
- return false;
- }
-
- @Override
- public void configureBeforeRunTaskDefaults(
- Key<? extends BeforeRunTask> providerID, BeforeRunTask task) {
- // Removed BlazeAndroidBeforeRunTaskProvider; this method won't be called anymore anyhow.
- }
-
- @Override
- public boolean isConfigurationSingletonByDefault() {
- return false;
- }
- }
-
- @NotNull
- public static BlazeAndroidBinaryRunConfigurationType getInstance() {
- return ConfigurationTypeUtil.findConfigurationType(
- BlazeAndroidBinaryRunConfigurationType.class);
- }
-
- @Override
- @NotNull
- public String getDisplayName() {
- return "Legacy " + Blaze.defaultBuildSystemName() + " Android Binary";
- }
-
- @Override
- public String getConfigurationTypeDescription() {
- return "Launch/debug configuration for android_binary rules. "
- + "Use Blaze Command instead; this legacy configuration type is being removed.";
- }
-
- @Override
- public Icon getIcon() {
- return AndroidIcons.Android;
- }
-
- @Override
- @NotNull
- public String getId() {
- // Used to look up this ConfigurationType.
- // Preserve value so legacy configurations can be loaded.
- return "BlazeAndroidBinaryRunConfigurationType";
- }
-
- @Override
- public BlazeAndroidBinaryRunConfigurationFactory[] getConfigurationFactories() {
- return new BlazeAndroidBinaryRunConfigurationFactory[] {factory};
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeDefaultActivityLocator.java b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeDefaultActivityLocator.java
index d6fcd4a..50c2dfd 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/BlazeDefaultActivityLocator.java
+++ b/aswb/src/com/google/idea/blaze/android/run/binary/BlazeDefaultActivityLocator.java
@@ -45,7 +45,13 @@
@NotNull
@Override
public String getQualifiedActivityName(@NotNull IDevice device) throws ActivityLocatorException {
- Manifest manifest = ManifestParser.getInstance(project).getManifest(mergedManifestFile);
+ // Run in a read action since otherwise, it might throw a read access exception.
+ Manifest manifest =
+ ApplicationManager.getApplication()
+ .runReadAction(
+ (Computable<Manifest>)
+ () -> ManifestParser.getInstance(project).getManifest(mergedManifestFile));
+
if (manifest == null) {
throw new ActivityLocatorException("Could not locate merged manifest");
}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeAndroidBinaryInstantRunContext.java b/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeAndroidBinaryInstantRunContext.java
deleted file mode 100644
index b35d0b2..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeAndroidBinaryInstantRunContext.java
+++ /dev/null
@@ -1,196 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.binary.instantrun;
-
-import com.android.ddmlib.IDevice;
-import com.android.tools.idea.fd.InstantRunBuildAnalyzer;
-import com.android.tools.idea.fd.InstantRunUtils;
-import com.android.tools.idea.run.ApplicationIdProvider;
-import com.android.tools.idea.run.ConsolePrinter;
-import com.android.tools.idea.run.ConsoleProvider;
-import com.android.tools.idea.run.LaunchOptions;
-import com.android.tools.idea.run.activity.DefaultStartActivityFlagsProvider;
-import com.android.tools.idea.run.activity.StartActivityFlagsProvider;
-import com.android.tools.idea.run.editor.AndroidDebugger;
-import com.android.tools.idea.run.editor.AndroidDebuggerState;
-import com.android.tools.idea.run.tasks.DebugConnectorTask;
-import com.android.tools.idea.run.tasks.LaunchTask;
-import com.android.tools.idea.run.tasks.LaunchTasksProvider;
-import com.android.tools.idea.run.tasks.UpdateSessionTasksProvider;
-import com.android.tools.idea.run.util.ProcessHandlerLaunchStatus;
-import com.google.common.collect.ImmutableList;
-import com.google.common.util.concurrent.Futures;
-import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryApplicationLaunchTaskProvider;
-import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryConsoleProvider;
-import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryRunConfigurationState;
-import com.google.idea.blaze.android.run.binary.UserIdHelper;
-import com.google.idea.blaze.android.run.runner.BlazeAndroidDeviceSelector;
-import com.google.idea.blaze.android.run.runner.BlazeAndroidLaunchTasksProvider;
-import com.google.idea.blaze.android.run.runner.BlazeAndroidRunConfigurationDebuggerManager;
-import com.google.idea.blaze.android.run.runner.BlazeAndroidRunContext;
-import com.google.idea.blaze.android.run.runner.BlazeApkBuildStep;
-import com.google.idea.blaze.base.model.primitives.Label;
-import com.intellij.execution.ExecutionException;
-import com.intellij.execution.configurations.RunConfiguration;
-import com.intellij.execution.runners.ExecutionEnvironment;
-import com.intellij.openapi.project.Project;
-import java.util.Set;
-import javax.annotation.Nullable;
-import org.jetbrains.android.facet.AndroidFacet;
-import org.jetbrains.annotations.NotNull;
-
-/** Run context for InstantRun. */
-public class BlazeAndroidBinaryInstantRunContext implements BlazeAndroidRunContext {
-
- private final Project project;
- private final AndroidFacet facet;
- private final RunConfiguration runConfiguration;
- private final ExecutionEnvironment env;
- private final BlazeAndroidBinaryRunConfigurationState configState;
-
- private final BlazeAndroidBinaryConsoleProvider consoleProvider;
- private final BlazeApkBuildStepInstantRun buildStep;
-
- public BlazeAndroidBinaryInstantRunContext(
- Project project,
- AndroidFacet facet,
- RunConfiguration runConfiguration,
- ExecutionEnvironment env,
- BlazeAndroidBinaryRunConfigurationState configState,
- Label label,
- ImmutableList<String> buildFlags) {
- this.project = project;
- this.facet = facet;
- this.runConfiguration = runConfiguration;
- this.env = env;
- this.configState = configState;
- this.consoleProvider = new BlazeAndroidBinaryConsoleProvider(project);
- this.buildStep = new BlazeApkBuildStepInstantRun(project, env, label, buildFlags);
- }
-
- @Override
- public BlazeAndroidDeviceSelector getDeviceSelector() {
- return new BlazeInstantRunDeviceSelector();
- }
-
- @Override
- public void augmentEnvironment(ExecutionEnvironment env) {
- InstantRunUtils.setInstantRunEnabled(env, true);
- }
-
- @Override
- public void augmentLaunchOptions(@NotNull LaunchOptions.Builder options) {
- options.setDeploy(true).setOpenLogcatAutomatically(true);
- }
-
- @NotNull
- @Override
- public ConsoleProvider getConsoleProvider() {
- return consoleProvider;
- }
-
- @Override
- public ApplicationIdProvider getApplicationIdProvider() throws ExecutionException {
- return Futures.get(buildStep.getApplicationIdProvider(), ExecutionException.class);
- }
-
- @Override
- public BlazeApkBuildStep getBuildStep() {
- return buildStep;
- }
-
- @Override
- public LaunchTasksProvider getLaunchTasksProvider(
- LaunchOptions.Builder launchOptionsBuilder,
- boolean isDebug,
- BlazeAndroidRunConfigurationDebuggerManager debuggerManager)
- throws ExecutionException {
- InstantRunBuildAnalyzer analyzer =
- Futures.get(buildStep.getInstantRunBuildAnalyzer(), ExecutionException.class);
-
- if (analyzer.canReuseProcessHandler()) {
- return new UpdateSessionTasksProvider(analyzer);
- }
- return new BlazeAndroidLaunchTasksProvider(
- project,
- this,
- getApplicationIdProvider(),
- launchOptionsBuilder,
- isDebug,
- true,
- debuggerManager);
- }
-
- @Override
- public ImmutableList<LaunchTask> getDeployTasks(IDevice device, LaunchOptions launchOptions)
- throws ExecutionException {
- InstantRunBuildAnalyzer analyzer =
- Futures.get(buildStep.getInstantRunBuildAnalyzer(), ExecutionException.class);
- return ImmutableList.<LaunchTask>builder()
- .addAll(analyzer.getDeployTasks(launchOptions))
- .add(analyzer.getNotificationTask())
- .build();
- }
-
- @Nullable
- @Override
- public LaunchTask getApplicationLaunchTask(
- LaunchOptions launchOptions,
- @Nullable Integer userId,
- AndroidDebugger androidDebugger,
- AndroidDebuggerState androidDebuggerState,
- ProcessHandlerLaunchStatus processHandlerLaunchStatus)
- throws ExecutionException {
- BlazeApkBuildStepInstantRun.BuildResult buildResult =
- Futures.get(buildStep.getBuildResult(), ExecutionException.class);
-
- final StartActivityFlagsProvider startActivityFlagsProvider =
- new DefaultStartActivityFlagsProvider(
- androidDebugger,
- androidDebuggerState,
- project,
- launchOptions.isDebug(),
- UserIdHelper.getFlagsFromUserId(userId));
-
- ApplicationIdProvider applicationIdProvider = getApplicationIdProvider();
- return BlazeAndroidBinaryApplicationLaunchTaskProvider.getApplicationLaunchTask(
- project,
- applicationIdProvider,
- buildResult.mergedManifestFile,
- configState,
- startActivityFlagsProvider,
- processHandlerLaunchStatus);
- }
-
- @Nullable
- @Override
- public DebugConnectorTask getDebuggerTask(
- AndroidDebugger androidDebugger,
- AndroidDebuggerState androidDebuggerState,
- Set<String> packageIds)
- throws ExecutionException {
- //noinspection unchecked
- return androidDebugger.getConnectDebuggerTask(
- env, null, packageIds, facet, androidDebuggerState, runConfiguration.getType().getId());
- }
-
- @Nullable
- @Override
- public Integer getUserId(IDevice device, ConsolePrinter consolePrinter)
- throws ExecutionException {
- return UserIdHelper.getUserIdFromConfigurationState(device, consolePrinter, configState);
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeApkBuildStepInstantRun.java b/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeApkBuildStepInstantRun.java
deleted file mode 100644
index 2830533..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeApkBuildStepInstantRun.java
+++ /dev/null
@@ -1,384 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.binary.instantrun;
-
-import com.android.ddmlib.IDevice;
-import com.android.tools.idea.fd.InstantRunBuildAnalyzer;
-import com.android.tools.idea.fd.InstantRunBuilder;
-import com.android.tools.idea.fd.InstantRunContext;
-import com.android.tools.idea.fd.InstantRunUtils;
-import com.android.tools.idea.fd.RunAsValidityService;
-import com.android.tools.idea.gradle.run.MakeBeforeRunTaskProvider;
-import com.android.tools.idea.run.AndroidDevice;
-import com.android.tools.idea.run.AndroidRunConfigContext;
-import com.android.tools.idea.run.AndroidSessionInfo;
-import com.android.tools.idea.run.ApkProvisionException;
-import com.android.tools.idea.run.ApplicationIdProvider;
-import com.android.tools.idea.run.DeviceFutures;
-import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Iterables;
-import com.google.common.collect.Lists;
-import com.google.common.util.concurrent.ListenableFuture;
-import com.google.common.util.concurrent.SettableFuture;
-import com.google.idea.blaze.android.manifest.ManifestParser;
-import com.google.idea.blaze.android.run.runner.BlazeAndroidDeviceSelector;
-import com.google.idea.blaze.android.run.runner.BlazeApkBuildStep;
-import com.google.idea.blaze.base.async.executor.BlazeExecutor;
-import com.google.idea.blaze.base.async.process.ExternalTask;
-import com.google.idea.blaze.base.async.process.LineProcessingOutputStream;
-import com.google.idea.blaze.base.command.BlazeCommand;
-import com.google.idea.blaze.base.command.BlazeCommandName;
-import com.google.idea.blaze.base.command.BlazeFlags;
-import com.google.idea.blaze.base.command.ExperimentalShowArtifactsLineProcessor;
-import com.google.idea.blaze.base.command.info.BlazeInfo;
-import com.google.idea.blaze.base.filecache.FileCaches;
-import com.google.idea.blaze.base.issueparser.IssueOutputLineProcessor;
-import com.google.idea.blaze.base.metrics.Action;
-import com.google.idea.blaze.base.model.primitives.Label;
-import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
-import com.google.idea.blaze.base.scope.BlazeContext;
-import com.google.idea.blaze.base.scope.ScopedTask;
-import com.google.idea.blaze.base.scope.output.IssueOutput;
-import com.google.idea.blaze.base.scope.scopes.LoggedTimingScope;
-import com.google.idea.blaze.base.settings.Blaze;
-import com.google.idea.blaze.base.util.SaveUtil;
-import com.google.repackaged.devtools.build.lib.rules.android.apkmanifest.ApkManifestOuterClass;
-import com.intellij.execution.Executor;
-import com.intellij.execution.process.ProcessHandler;
-import com.intellij.execution.runners.ExecutionEnvironment;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.project.Project;
-import java.io.File;
-import java.io.FileInputStream;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.PrintWriter;
-import java.lang.reflect.InvocationTargetException;
-import java.util.List;
-import java.util.concurrent.CancellationException;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.TimeoutException;
-import javax.annotation.Nullable;
-import org.jetbrains.annotations.NotNull;
-
-/** Builds the APK using normal blaze build. */
-class BlazeApkBuildStepInstantRun implements BlazeApkBuildStep {
- private static final Logger LOG = Logger.getInstance(BlazeApkBuildStepInstantRun.class);
-
- private final Project project;
- private final Executor executor;
- private final ExecutionEnvironment env;
- private final Label label;
- private final ImmutableList<String> buildFlags;
- private final File instantRunArtifactDirectory;
- private final File instantRunGradleBuildFile;
- private final File instantRunBuildInfoFile;
- private final File instantRunGradlePropertiesFile;
-
- public static class BuildResult {
- public final File executionRoot;
- public final File mergedManifestFile;
- public final File apkManifestProtoFile;
- public final ApkManifestOuterClass.ApkManifest apkManifestProto;
-
- public BuildResult(
- File executionRoot,
- File mergedManifestFile,
- File apkManifestProtoFile,
- ApkManifestOuterClass.ApkManifest apkManifestProto) {
- this.executionRoot = executionRoot;
- this.mergedManifestFile = mergedManifestFile;
- this.apkManifestProtoFile = apkManifestProtoFile;
- this.apkManifestProto = apkManifestProto;
- }
- }
-
- private final SettableFuture<BuildResult> buildResultFuture = SettableFuture.create();
- private final SettableFuture<ApplicationIdProvider> applicationIdProviderFuture =
- SettableFuture.create();
- private final SettableFuture<InstantRunContext> instantRunContextFuture = SettableFuture.create();
- private final SettableFuture<InstantRunBuildAnalyzer> instantRunBuildAnalyzerFuture =
- SettableFuture.create();
-
- public BlazeApkBuildStepInstantRun(
- Project project, ExecutionEnvironment env, Label label, ImmutableList<String> buildFlags) {
- this.project = project;
- this.executor = env.getExecutor();
- this.env = env;
- this.label = label;
- this.buildFlags = buildFlags;
- this.instantRunArtifactDirectory =
- BlazeInstantRunGradleIntegration.getInstantRunArtifactDirectory(project, label);
- this.instantRunBuildInfoFile =
- new File(instantRunArtifactDirectory, "build/reload-dex/debug/build-info.xml");
- this.instantRunGradleBuildFile = new File(instantRunArtifactDirectory, "build.gradle");
- this.instantRunGradlePropertiesFile =
- new File(instantRunArtifactDirectory, "gradle.properties");
- }
-
- @Override
- public boolean build(
- BlazeContext context, BlazeAndroidDeviceSelector.DeviceSession deviceSession) {
- if (!instantRunArtifactDirectory.exists() && !instantRunArtifactDirectory.mkdirs()) {
- IssueOutput.error(
- "Could not create instant run artifact directory: " + instantRunArtifactDirectory)
- .submit(context);
- return false;
- }
-
- BuildResult buildResult = buildApkManifest(context);
- if (buildResult == null) {
- return false;
- }
-
- String gradleUrl = BlazeInstantRunGradleIntegration.getGradleUrl(context);
- if (gradleUrl == null) {
- return false;
- }
-
- ApplicationIdProvider applicationIdProvider =
- new BlazeInstantRunApplicationIdProvider(project, buildResult);
- applicationIdProviderFuture.set(applicationIdProvider);
-
- // Write build.gradle
- try (PrintWriter printWriter = new PrintWriter(instantRunGradleBuildFile)) {
- printWriter.print(
- BlazeInstantRunGradleIntegration.getGradleBuildInfoString(
- gradleUrl, buildResult.executionRoot, buildResult.apkManifestProtoFile));
- } catch (IOException e) {
- IssueOutput.error("Could not write build.gradle file: " + e).submit(context);
- return false;
- }
-
- // Write gradle.properties
- try (PrintWriter printWriter = new PrintWriter(instantRunGradlePropertiesFile)) {
- printWriter.print(BlazeInstantRunGradleIntegration.getGradlePropertiesString());
- } catch (IOException e) {
- IssueOutput.error("Could not write build.gradle file: " + e).submit(context);
- return false;
- }
-
- String applicationId = null;
- try {
- applicationId = applicationIdProvider.getPackageName();
- } catch (ApkProvisionException e) {
- return false;
- }
-
- return invokeGradleIrTasks(context, deviceSession, buildResult, applicationId);
- }
-
- private BuildResult buildApkManifest(BlazeContext context) {
- final ScopedTask buildTask =
- new ScopedTask(context) {
- @Override
- protected void execute(@NotNull BlazeContext context) {
- WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
- String executionRoot = getExecutionRoot(context, workspaceRoot);
- if (executionRoot == null) {
- IssueOutput.error("Could not get execution root").submit(context);
- return;
- }
-
- BlazeCommand.Builder command =
- BlazeCommand.builder(Blaze.getBuildSystem(project), BlazeCommandName.BUILD);
-
- command
- .addTargets(label)
- .addBlazeFlags(buildFlags)
- .addBlazeFlags("--output_groups=apk_manifest")
- .addBlazeFlags(BlazeFlags.EXPERIMENTAL_SHOW_ARTIFACTS);
-
- List<File> apkManifestFiles = Lists.newArrayList();
-
- SaveUtil.saveAllFiles();
- int retVal =
- ExternalTask.builder(workspaceRoot)
- .addBlazeCommand(command.build())
- .context(context)
- .stderr(
- LineProcessingOutputStream.of(
- new ExperimentalShowArtifactsLineProcessor(
- apkManifestFiles, fileName -> fileName.endsWith("apk_manifest")),
- new IssueOutputLineProcessor(project, context, workspaceRoot)))
- .build()
- .run(new LoggedTimingScope(project, Action.BLAZE_BUILD));
- FileCaches.refresh(project);
-
- if (retVal != 0) {
- context.setHasError();
- return;
- }
-
- File apkManifestFile = Iterables.getOnlyElement(apkManifestFiles, null);
- if (apkManifestFile == null) {
- IssueOutput.error("Could not find APK manifest file").submit(context);
- return;
- }
-
- ApkManifestOuterClass.ApkManifest apkManifestProto;
- try (InputStream inputStream = new FileInputStream(apkManifestFile)) {
- apkManifestProto = ApkManifestOuterClass.ApkManifest.parseFrom(inputStream);
- } catch (IOException e) {
- LOG.error(e);
- IssueOutput.error("Error parsing apk proto").submit(context);
- return;
- }
-
- // Refresh the manifest
- File mergedManifestFile =
- new File(executionRoot, apkManifestProto.getAndroidManifest().getExecRootPath());
- ManifestParser.getInstance(project)
- .refreshManifests(ImmutableList.of(mergedManifestFile));
-
- BuildResult buildResult =
- new BuildResult(
- new File(executionRoot), mergedManifestFile, apkManifestFile, apkManifestProto);
- buildResultFuture.set(buildResult);
- }
- };
-
- BlazeExecutor.submitTask(
- project,
- String.format("Executing %s apk build", Blaze.buildSystemName(project)),
- buildTask);
-
- try {
- BuildResult buildResult = buildResultFuture.get();
- if (!context.shouldContinue()) {
- return null;
- }
- return buildResult;
- } catch (InterruptedException | ExecutionException e) {
- context.setHasError();
- } catch (CancellationException e) {
- context.setCancelled();
- }
- return null;
- }
-
- private boolean invokeGradleIrTasks(
- BlazeContext context,
- BlazeAndroidDeviceSelector.DeviceSession deviceSession,
- BuildResult buildResult,
- String applicationId) {
- InstantRunContext instantRunContext =
- new BlazeInstantRunContext(
- project, buildResult.apkManifestProto, applicationId, instantRunBuildInfoFile);
- instantRunContextFuture.set(instantRunContext);
- ProcessHandler previousSessionProcessHandler =
- deviceSession.sessionInfo != null ? deviceSession.sessionInfo.getProcessHandler() : null;
- DeviceFutures deviceFutures = deviceSession.deviceFutures;
- assert deviceFutures != null;
- List<AndroidDevice> targetDevices = deviceFutures.getDevices();
- AndroidDevice androidDevice = targetDevices.get(0);
- IDevice device = getLaunchedDevice(androidDevice);
-
- AndroidRunConfigContext runConfigContext = new AndroidRunConfigContext();
- runConfigContext.setTargetDevices(deviceFutures);
-
- AndroidSessionInfo info = deviceSession.sessionInfo;
- runConfigContext.setSameExecutorAsPreviousSession(
- info != null && executor.getId().equals(info.getExecutorId()));
- runConfigContext.setCleanRerun(InstantRunUtils.isCleanReRun(env));
-
- InstantRunBuilder instantRunBuilder =
- new InstantRunBuilder(
- device,
- instantRunContext,
- runConfigContext,
- new BlazeInstantRunTasksProvider(),
- RunAsValidityService.getInstance());
-
- try {
- List<String> cmdLineArgs = Lists.newArrayList();
- cmdLineArgs.addAll(MakeBeforeRunTaskProvider.getDeviceSpecificArguments(targetDevices));
- BlazeInstantRunGradleTaskRunner taskRunner =
- new BlazeInstantRunGradleTaskRunner(project, context, instantRunGradleBuildFile);
- boolean success = instantRunBuilder.build(taskRunner, cmdLineArgs);
- LOG.info("Gradle invocation complete, success = " + success);
- if (!success) {
- return false;
- }
- } catch (InvocationTargetException e) {
- LOG.info("Unexpected error while launching gradle before run tasks", e);
- return false;
- } catch (InterruptedException e) {
- LOG.info("Interrupted while launching gradle before run tasks");
- Thread.currentThread().interrupt();
- return false;
- }
-
- InstantRunBuildAnalyzer analyzer =
- new InstantRunBuildAnalyzer(project, instantRunContext, previousSessionProcessHandler);
- instantRunBuildAnalyzerFuture.set(analyzer);
- return true;
- }
-
- ListenableFuture<BuildResult> getBuildResult() {
- return buildResultFuture;
- }
-
- ListenableFuture<ApplicationIdProvider> getApplicationIdProvider() {
- return applicationIdProviderFuture;
- }
-
- ListenableFuture<InstantRunContext> getInstantRunContext() {
- return instantRunContextFuture;
- }
-
- ListenableFuture<InstantRunBuildAnalyzer> getInstantRunBuildAnalyzer() {
- return instantRunBuildAnalyzerFuture;
- }
-
- private String getExecutionRoot(BlazeContext context, WorkspaceRoot workspaceRoot) {
- ListenableFuture<String> execRootFuture =
- BlazeInfo.getInstance()
- .runBlazeInfo(
- context,
- Blaze.getBuildSystem(project),
- workspaceRoot,
- buildFlags,
- BlazeInfo.EXECUTION_ROOT_KEY);
- try {
- return execRootFuture.get();
- } catch (InterruptedException e) {
- context.setCancelled();
- } catch (ExecutionException e) {
- LOG.error(e);
- context.setHasError();
- }
- return null;
- }
-
- @Nullable
- private static IDevice getLaunchedDevice(@NotNull AndroidDevice device) {
- if (!device.getLaunchedDevice().isDone()) {
- // If we don't have access to the device (this happens if the AVD is still launching)
- return null;
- }
-
- try {
- return device.getLaunchedDevice().get(1, TimeUnit.MILLISECONDS);
- } catch (InterruptedException e) {
- Thread.currentThread().interrupt();
- return null;
- } catch (ExecutionException | TimeoutException e) {
- return null;
- }
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunApplicationIdProvider.java b/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunApplicationIdProvider.java
deleted file mode 100644
index ab1461e..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunApplicationIdProvider.java
+++ /dev/null
@@ -1,65 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.binary.instantrun;
-
-import com.android.tools.idea.run.ApkProvisionException;
-import com.android.tools.idea.run.ApplicationIdProvider;
-import com.google.idea.blaze.android.manifest.ManifestParser;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Computable;
-import java.io.File;
-import org.jetbrains.android.dom.manifest.Manifest;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/** Application id provider for blaze instant run. */
-public class BlazeInstantRunApplicationIdProvider implements ApplicationIdProvider {
- private final Project project;
- private final BlazeApkBuildStepInstantRun.BuildResult buildResult;
-
- public BlazeInstantRunApplicationIdProvider(
- Project project, BlazeApkBuildStepInstantRun.BuildResult buildResult) {
- this.project = project;
- this.buildResult = buildResult;
- }
-
- @NotNull
- @Override
- public String getPackageName() throws ApkProvisionException {
- File manifestFile =
- new File(
- buildResult.executionRoot,
- buildResult.apkManifestProto.getAndroidManifest().getExecRootPath());
- Manifest manifest = ManifestParser.getInstance(project).getManifest(manifestFile);
- if (manifest == null) {
- throw new ApkProvisionException("Could not find merged manifest: " + manifestFile);
- }
- String applicationId =
- ApplicationManager.getApplication()
- .runReadAction((Computable<String>) () -> manifest.getPackage().getValue());
- if (applicationId == null) {
- throw new ApkProvisionException("No application id in merged manifest: " + manifestFile);
- }
- return applicationId;
- }
-
- @Nullable
- @Override
- public String getTestPackageName() throws ApkProvisionException {
- return null;
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunContext.java b/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunContext.java
deleted file mode 100644
index 9ea7c03..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunContext.java
+++ /dev/null
@@ -1,105 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.binary.instantrun;
-
-import com.android.tools.fd.client.InstantRunBuildInfo;
-import com.android.tools.idea.fd.BuildSelection;
-import com.android.tools.idea.fd.FileChangeListener;
-import com.android.tools.idea.fd.InstantRunContext;
-import com.google.common.hash.HashCode;
-import com.google.repackaged.devtools.build.lib.rules.android.apkmanifest.ApkManifestOuterClass;
-import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.project.Project;
-import java.io.File;
-import java.io.IOException;
-import java.nio.charset.StandardCharsets;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/** Blaze implementation of instant run context. */
-public class BlazeInstantRunContext implements InstantRunContext {
- private static final Logger LOG = Logger.getInstance(BlazeInstantRunContext.class);
- private final Project project;
- private final ApkManifestOuterClass.ApkManifest apkManifest;
- private final String applicationId;
- private final File instantRunBuildInfoFile;
- private BuildSelection buildSelection;
-
- BlazeInstantRunContext(
- Project project,
- ApkManifestOuterClass.ApkManifest apkManifest,
- String applicationId,
- File instantRunBuildInfoFile) {
- this.project = project;
- this.apkManifest = apkManifest;
- this.applicationId = applicationId;
- this.instantRunBuildInfoFile = instantRunBuildInfoFile;
- }
-
- @NotNull
- @Override
- public String getApplicationId() {
- return applicationId;
- }
-
- @NotNull
- @Override
- public HashCode getManifestResourcesHash() {
- // TODO b/28373160
- return HashCode.fromInt(0);
- }
-
- @Override
- public boolean usesMultipleProcesses() {
- // TODO(tomlu) -- does this make sense in blaze? We can of course just parse the manifest.
- return false;
- }
-
- @Nullable
- @Override
- public FileChangeListener.Changes getFileChangesAndReset() {
- return null;
- }
-
- @Nullable
- @Override
- public InstantRunBuildInfo getInstantRunBuildInfo() {
- if (instantRunBuildInfoFile.exists()) {
- try {
- String xml =
- new String(
- Files.readAllBytes(Paths.get(instantRunBuildInfoFile.getPath())),
- StandardCharsets.UTF_8);
- return InstantRunBuildInfo.get(xml);
- } catch (IOException e) {
- LOG.error(e);
- }
- }
- return null;
- }
-
- @Override
- public void setBuildSelection(@NotNull BuildSelection buildSelection) {
- this.buildSelection = buildSelection;
- }
-
- @Override
- public BuildSelection getBuildSelection() {
- return buildSelection;
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunDeviceSelector.java b/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunDeviceSelector.java
deleted file mode 100644
index 8c26fc4..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunDeviceSelector.java
+++ /dev/null
@@ -1,96 +0,0 @@
-/*
- * Copyright (C) 2016 The Android Open Source Project
- *
- * 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.idea.blaze.android.run.binary.instantrun;
-
-import com.android.ddmlib.IDevice;
-import com.android.tools.idea.fd.InstantRunManager;
-import com.android.tools.idea.fd.InstantRunUtils;
-import com.android.tools.idea.run.AndroidSessionInfo;
-import com.android.tools.idea.run.DeviceFutures;
-import com.google.idea.blaze.android.run.runner.BlazeAndroidDeviceSelector;
-import com.google.idea.blaze.android.run.runner.BlazeAndroidRunConfigurationDeployTargetManager;
-import com.intellij.execution.ExecutionException;
-import com.intellij.execution.Executor;
-import com.intellij.execution.runners.ExecutionEnvironment;
-import com.intellij.openapi.project.Project;
-import java.util.List;
-import javax.annotation.Nullable;
-import org.jetbrains.android.facet.AndroidFacet;
-
-/** Tries to reuse devices from a previous session. */
-public class BlazeInstantRunDeviceSelector implements BlazeAndroidDeviceSelector {
- NormalDeviceSelector normalDeviceSelector = new NormalDeviceSelector();
-
- @Override
- public DeviceSession getDevice(
- Project project,
- AndroidFacet facet,
- BlazeAndroidRunConfigurationDeployTargetManager deployTargetManager,
- Executor executor,
- ExecutionEnvironment env,
- AndroidSessionInfo info,
- boolean debug,
- int runConfigId)
- throws ExecutionException {
- DeviceFutures deviceFutures = null;
- if (info != null) {
- // if there is an existing previous session,
- // then see if we can detect devices to fast deploy to
- deviceFutures = getFastDeployDevices(executor, info);
-
- if (InstantRunUtils.isReRun(env)) {
- info.getProcessHandler().destroyProcess();
- info = null;
- }
- }
-
- if (deviceFutures != null) {
- return new DeviceSession(null, deviceFutures, info);
- }
-
- // Fall back to normal device selection
- return normalDeviceSelector.getDevice(
- project, facet, deployTargetManager, executor, env, info, debug, runConfigId);
- }
-
- @Nullable
- private static DeviceFutures getFastDeployDevices(Executor executor, AndroidSessionInfo info) {
- if (!info.getExecutorId().equals(executor.getId())) {
- String msg =
- String.format(
- "Cannot Instant Run since old executor (%1$s) doesn't match current executor (%2$s)",
- info.getExecutorId(), executor.getId());
- InstantRunManager.LOG.info(msg);
- return null;
- }
-
- List<IDevice> devices = info.getDevices();
- if (devices == null || devices.isEmpty()) {
- InstantRunManager.LOG.info(
- "Cannot Instant Run since we could not locate "
- + "the devices from the existing launch session");
- return null;
- }
-
- if (devices.size() > 1) {
- InstantRunManager.LOG.info(
- "Last run was on > 1 device, not reusing devices and prompting again");
- return null;
- }
-
- return DeviceFutures.forDevices(devices);
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunGradleIntegration.java b/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunGradleIntegration.java
deleted file mode 100644
index a9873ca..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunGradleIntegration.java
+++ /dev/null
@@ -1,126 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.binary.instantrun;
-
-import com.android.SdkConstants;
-import com.google.common.base.Joiner;
-import com.google.common.hash.Hashing;
-import com.google.idea.blaze.base.async.process.ExternalTask;
-import com.google.idea.blaze.base.async.process.LineProcessingOutputStream;
-import com.google.idea.blaze.base.async.process.PrintOutputLineProcessor;
-import com.google.idea.blaze.base.model.primitives.Label;
-import com.google.idea.blaze.base.scope.BlazeContext;
-import com.google.idea.blaze.base.scope.output.IssueOutput;
-import com.google.idea.blaze.base.scope.output.StatusOutput;
-import com.google.idea.blaze.base.settings.BlazeImportSettings;
-import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
-import com.google.idea.blaze.base.sync.data.BlazeDataStorage;
-import com.google.idea.common.experiments.DeveloperFlag;
-import com.google.idea.common.experiments.StringExperiment;
-import com.intellij.openapi.application.PathManager;
-import com.intellij.openapi.project.Project;
-import java.io.File;
-import javax.annotation.Nullable;
-
-/** Defines where instant run storage and artifacts go. */
-class BlazeInstantRunGradleIntegration {
- private static final String INSTANT_RUN_SUBDIRECTORY = "instantrun";
-
- private static final StringExperiment LOCAL_GRADLE_VERSION =
- new StringExperiment("use.local.gradle.version");
- private static final DeveloperFlag REBUILD_LOCAL_GRADLE =
- new DeveloperFlag("rebuild.local.gradle");
-
- /** Gets a unique directory for a given target that can be used for the build process. */
- static File getInstantRunArtifactDirectory(Project project, Label target) {
- BlazeImportSettings importSettings =
- BlazeImportSettingsManager.getInstance(project).getImportSettings();
- assert importSettings != null;
- File dataSubDirectory = BlazeDataStorage.getProjectDataDir(importSettings);
- File instantRunDirectory = new File(dataSubDirectory, INSTANT_RUN_SUBDIRECTORY);
- String targetHash = Hashing.md5().hashUnencodedChars(target.toString()).toString();
- return new File(instantRunDirectory, targetHash);
- }
-
- @Nullable
- static String getGradleUrl(BlazeContext context) {
- String localGradleVersion = LOCAL_GRADLE_VERSION.getValue();
- boolean isDevMode = localGradleVersion != null;
-
- if (isDevMode) {
- String toolsIdeaPath = PathManager.getHomePath();
- File toolsDir = new File(toolsIdeaPath).getParentFile();
- File repoDir = toolsDir.getParentFile();
- File localGradleDirectory =
- new File(
- new File(repoDir, "out/repo/com/android/tools/build/builder"), localGradleVersion);
- if (REBUILD_LOCAL_GRADLE.getValue() || !localGradleDirectory.exists()) {
- // Build gradle
- context.output(new StatusOutput("Building local Gradle..."));
- int retVal =
- ExternalTask.builder(toolsDir)
- .args("./gradlew", ":init", ":publishLocal")
- .stdout(LineProcessingOutputStream.of(new PrintOutputLineProcessor(context)))
- .build()
- .run();
-
- if (retVal != 0) {
- IssueOutput.error("Gradle build failed.").submit(context);
- return null;
- }
- }
- return new File(repoDir, "out/repo").getPath();
- }
-
- // Not supported yet
- IssueOutput.error(
- "You must specify 'use.local.gradle.version' experiment, "
- + "non-local gradle not supported yet.")
- .submit(context);
- return null;
- }
-
- static String getGradlePropertiesString() {
- return Joiner.on('\n')
- .join("org.gradle.daemon=true", "org.gradle.jvmargs=-XX:MaxPermSize=1024m -Xmx4096m");
- }
-
- static String getGradleBuildInfoString(
- String gradleUrl, File executionRoot, File apkManifestFile) {
- String template =
- Joiner.on('\n')
- .join(
- "buildscript {",
- " repositories {",
- " jcenter()",
- " maven { url '%s' }",
- " }",
- " dependencies {",
- " classpath 'com.android.tools.build:gradle:%s'",
- " }",
- "}",
- "apply plugin: 'com.android.external.build'",
- "externalBuild {",
- " executionRoot = '%s'",
- " buildManifestPath = '%s'",
- "}");
- String gradleVersion = LOCAL_GRADLE_VERSION.getValue();
- gradleVersion = gradleVersion != null ? gradleVersion : SdkConstants.GRADLE_LATEST_VERSION;
-
- return String.format(
- template, gradleUrl, gradleVersion, executionRoot.getPath(), apkManifestFile.getPath());
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunGradleTaskRunner.java b/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunGradleTaskRunner.java
deleted file mode 100644
index bdeab5a..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunGradleTaskRunner.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.binary.instantrun;
-
-import static com.android.tools.idea.gradle.util.GradleUtil.GRADLE_SYSTEM_ID;
-import static com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskType.EXECUTE_TASK;
-
-import com.android.builder.model.AndroidProject;
-import com.android.tools.idea.gradle.invoker.GradleInvocationResult;
-import com.android.tools.idea.gradle.invoker.GradleInvoker;
-import com.android.tools.idea.gradle.run.GradleTaskRunner;
-import com.android.tools.idea.gradle.util.AndroidGradleSettings;
-import com.android.tools.idea.gradle.util.BuildMode;
-import com.google.common.base.Strings;
-import com.google.common.collect.ImmutableList;
-import com.google.idea.blaze.base.scope.BlazeContext;
-import com.google.idea.blaze.base.scope.output.PrintOutput;
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskId;
-import com.intellij.openapi.externalSystem.model.task.ExternalSystemTaskNotificationListenerAdapter;
-import com.intellij.openapi.project.Project;
-import com.intellij.util.concurrency.Semaphore;
-import java.io.File;
-import java.lang.reflect.InvocationTargetException;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicBoolean;
-import javax.swing.SwingUtilities;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-class BlazeInstantRunGradleTaskRunner implements GradleTaskRunner {
- private final Project project;
- private final BlazeContext context;
- private final File instantRunGradleBuildFile;
-
- public BlazeInstantRunGradleTaskRunner(
- Project project, BlazeContext context, File instantRunGradleBuildFile) {
- this.project = project;
- this.context = context;
- this.instantRunGradleBuildFile = instantRunGradleBuildFile;
- }
-
- @Override
- public boolean run(
- @NotNull List<String> tasks,
- @Nullable BuildMode buildMode,
- @NotNull List<String> commandLineArguments)
- throws InvocationTargetException, InterruptedException {
- assert !ApplicationManager.getApplication().isDispatchThread();
-
- final GradleInvoker gradleInvoker = GradleInvoker.getInstance(project);
-
- final AtomicBoolean success = new AtomicBoolean();
- final Semaphore done = new Semaphore();
- done.down();
-
- final GradleInvoker.AfterGradleInvocationTask afterTask =
- new GradleInvoker.AfterGradleInvocationTask() {
- @Override
- public void execute(@NotNull GradleInvocationResult result) {
- success.set(result.isBuildSuccessful());
- gradleInvoker.removeAfterGradleInvocationTask(this);
- done.up();
- }
- };
-
- ExternalSystemTaskId taskId =
- ExternalSystemTaskId.create(GRADLE_SYSTEM_ID, EXECUTE_TASK, project);
- List<String> jvmArguments = ImmutableList.of();
-
- // https://code.google.com/p/android/issues/detail?id=213040 -
- // make split apks only available if an env var is set
- List<String> args = new ArrayList<>(commandLineArguments);
- if (!Boolean.valueOf(System.getenv(GradleTaskRunner.USE_SPLIT_APK))) {
- // force multi dex when the env var is not set to true
- args.add(
- AndroidGradleSettings.createProjectProperty(
- AndroidProject.PROPERTY_SIGNING_COLDSWAP_MODE, "MULTIDEX"));
- }
-
- // To ensure that the "Run Configuration" waits for the Gradle tasks to be executed,
- // we use SwingUtilities.invokeAndWait. I tried
- // using Application.invokeAndWait but it never worked.
- // IDEA also uses SwingUtilities in this scenario (see CompileStepBeforeRun.)
- SwingUtilities.invokeAndWait(
- () -> {
- gradleInvoker.addAfterGradleInvocationTask(afterTask);
- gradleInvoker.executeTasks(
- tasks,
- jvmArguments,
- args,
- taskId,
- new GradleNotificationListener(),
- instantRunGradleBuildFile,
- false,
- true);
- });
-
- done.waitFor();
- return success.get();
- }
-
- class GradleNotificationListener extends ExternalSystemTaskNotificationListenerAdapter {
- @Override
- public void onTaskOutput(
- @NotNull ExternalSystemTaskId id, @NotNull String text, boolean stdOut) {
- super.onTaskOutput(id, text, stdOut);
- String toPrint = text.trim();
- if (!Strings.isNullOrEmpty(toPrint)) {
- context.output(
- new PrintOutput(
- toPrint, stdOut ? PrintOutput.OutputType.NORMAL : PrintOutput.OutputType.ERROR));
- }
- }
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunTasksProvider.java b/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunTasksProvider.java
deleted file mode 100644
index 52a82f7..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/BlazeInstantRunTasksProvider.java
+++ /dev/null
@@ -1,36 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.binary.instantrun;
-
-import com.android.tools.idea.fd.InstantRunTasksProvider;
-import com.google.common.collect.ImmutableList;
-import java.util.List;
-import org.jetbrains.annotations.NotNull;
-
-/** Returns blaze-specific instant run tasks. */
-public class BlazeInstantRunTasksProvider implements InstantRunTasksProvider {
- @NotNull
- @Override
- public List<String> getCleanAndGenerateSourcesTasks() {
- return ImmutableList.of();
- }
-
- @NotNull
- @Override
- public List<String> getFullBuildTasks() {
- return ImmutableList.of("process");
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/mobileinstall/BlazeAndroidBinaryMobileInstallRunContext.java b/aswb/src/com/google/idea/blaze/android/run/binary/mobileinstall/BlazeAndroidBinaryMobileInstallRunContext.java
index a25eba9..2ea7ebc 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/mobileinstall/BlazeAndroidBinaryMobileInstallRunContext.java
+++ b/aswb/src/com/google/idea/blaze/android/run/binary/mobileinstall/BlazeAndroidBinaryMobileInstallRunContext.java
@@ -30,6 +30,7 @@
import com.android.tools.idea.run.util.ProcessHandlerLaunchStatus;
import com.google.common.collect.ImmutableList;
import com.google.common.util.concurrent.Futures;
+import com.google.idea.blaze.android.compatibility.Compatibility;
import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryApplicationIdProvider;
import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryApplicationLaunchTaskProvider;
import com.google.idea.blaze.android.run.binary.BlazeAndroidBinaryConsoleProvider;
@@ -159,14 +160,22 @@
@Nullable
@Override
+ @SuppressWarnings("unchecked")
public DebugConnectorTask getDebuggerTask(
AndroidDebugger androidDebugger,
AndroidDebuggerState androidDebuggerState,
- Set<String> packageIds)
+ Set<String> packageIds,
+ boolean monitorRemoteProcess)
throws ExecutionException {
- //noinspection unchecked
- return androidDebugger.getConnectDebuggerTask(
- env, null, packageIds, facet, androidDebuggerState, runConfiguration.getType().getId());
+ return Compatibility.getConnectDebuggerTask(
+ androidDebugger,
+ env,
+ null,
+ packageIds,
+ facet,
+ androidDebuggerState,
+ runConfiguration.getType().getId(),
+ monitorRemoteProcess);
}
@Nullable
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/mobileinstall/BlazeApkBuildStepMobileInstall.java b/aswb/src/com/google/idea/blaze/android/run/binary/mobileinstall/BlazeApkBuildStepMobileInstall.java
index 24d49b6..1256ff4 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/mobileinstall/BlazeApkBuildStepMobileInstall.java
+++ b/aswb/src/com/google/idea/blaze/android/run/binary/mobileinstall/BlazeApkBuildStepMobileInstall.java
@@ -23,6 +23,7 @@
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import com.google.common.util.concurrent.UncheckedExecutionException;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidSdkUtils;
import com.google.idea.blaze.android.run.deployinfo.BlazeAndroidDeployInfo;
import com.google.idea.blaze.android.run.deployinfo.BlazeApkDeployInfoProtoHelper;
import com.google.idea.blaze.android.run.runner.BlazeAndroidDeviceSelector;
@@ -56,8 +57,6 @@
import java.nio.file.Paths;
import java.util.concurrent.CancellationException;
import javax.annotation.Nullable;
-import org.jetbrains.android.sdk.AndroidSdkUtils;
-import org.jetbrains.annotations.NotNull;
/** Builds and installs the APK using mobile-install. */
public class BlazeApkBuildStepMobileInstall implements BlazeApkBuildStep {
@@ -89,7 +88,7 @@
final ScopedTask buildTask =
new ScopedTask(context) {
@Override
- protected void execute(@NotNull BlazeContext context) {
+ protected void execute(BlazeContext context) {
boolean incrementalInstall = env.getExecutor() instanceof IncrementalInstallExecutor;
DeviceFutures deviceFutures = deviceSession.deviceFutures;
@@ -203,8 +202,7 @@
}
@Nullable
- private static IDevice resolveDevice(
- @NotNull BlazeContext context, @NotNull DeviceFutures deviceFutures) {
+ private static IDevice resolveDevice(BlazeContext context, DeviceFutures deviceFutures) {
if (deviceFutures.get().size() != 1) {
IssueOutput.error("Only one device can be used with mobile-install.").submit(context);
return null;
diff --git a/aswb/src/com/google/idea/blaze/android/run/deployinfo/BlazeAndroidDeployInfo.java b/aswb/src/com/google/idea/blaze/android/run/deployinfo/BlazeAndroidDeployInfo.java
index e5f5ad3..afb7909 100644
--- a/aswb/src/com/google/idea/blaze/android/run/deployinfo/BlazeAndroidDeployInfo.java
+++ b/aswb/src/com/google/idea/blaze/android/run/deployinfo/BlazeAndroidDeployInfo.java
@@ -18,7 +18,9 @@
import com.google.common.collect.Lists;
import com.google.idea.blaze.android.manifest.ManifestParser;
import com.google.repackaged.devtools.build.lib.rules.android.deployinfo.AndroidDeployInfoOuterClass;
+import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Computable;
import java.io.File;
import java.util.List;
import java.util.Objects;
@@ -49,7 +51,11 @@
@Nullable
public Manifest getMergedManifest() {
File manifestFile = getMergedManifestFile();
- return ManifestParser.getInstance(project).getManifest(manifestFile);
+ // Run in a read action since otherwise, it might throw a read access exception.
+ return ApplicationManager.getApplication()
+ .runReadAction(
+ (Computable<Manifest>)
+ () -> ManifestParser.getInstance(project).getManifest(manifestFile));
}
public List<File> getAdditionalMergedManifestFiles() {
diff --git a/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidLaunchTasksProvider.java b/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidLaunchTasksProvider.java
index 7354b25..dacc20b 100644
--- a/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidLaunchTasksProvider.java
+++ b/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidLaunchTasksProvider.java
@@ -169,7 +169,8 @@
}
try {
- return runContext.getDebuggerTask(androidDebugger, androidDebuggerState, packageIds);
+ return runContext.getDebuggerTask(
+ androidDebugger, androidDebuggerState, packageIds, monitorRemoteProcess());
} catch (ExecutionException e) {
launchStatus.terminateLaunch(e.getMessage());
return null;
diff --git a/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidRunConfigurationRunner.java b/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidRunConfigurationRunner.java
index 76e3bfc..6d8feb4 100644
--- a/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidRunConfigurationRunner.java
+++ b/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidRunConfigurationRunner.java
@@ -36,6 +36,7 @@
import com.google.idea.blaze.base.experiments.ExperimentScope;
import com.google.idea.blaze.base.metrics.Action;
import com.google.idea.blaze.base.run.confighandler.BlazeCommandRunConfigurationRunner;
+import com.google.idea.blaze.base.run.smrunner.SmRunnerUtils;
import com.google.idea.blaze.base.scope.Scope;
import com.google.idea.blaze.base.scope.output.IssueOutput;
import com.google.idea.blaze.base.scope.scopes.BlazeConsoleScope;
@@ -79,7 +80,7 @@
private static final Key<BlazeAndroidRunContext> RUN_CONTEXT_KEY =
Key.create("blaze.run.context");
- private static final Key<BlazeAndroidDeviceSelector.DeviceSession> DEVICE_SESSION_KEY =
+ public static final Key<BlazeAndroidDeviceSelector.DeviceSession> DEVICE_SESSION_KEY =
Key.create("blaze.device.session");
private final Module module;
@@ -251,7 +252,17 @@
@Nullable
@Override
- public ExecutionResult execute(Executor executor, @NotNull ProgramRunner runner)
+ public ExecutionResult execute(Executor executor, ProgramRunner runner)
+ throws ExecutionException {
+ DefaultExecutionResult result = executeInner(executor, runner);
+ if (result == null) {
+ return null;
+ }
+ return SmRunnerUtils.attachRerunFailedTestsAction(result);
+ }
+
+ @Nullable
+ private DefaultExecutionResult executeInner(Executor executor, @NotNull ProgramRunner<?> runner)
throws ExecutionException {
ProcessHandler processHandler;
ConsoleView console;
diff --git a/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidRunContext.java b/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidRunContext.java
index 1778a63..a0653a1 100644
--- a/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidRunContext.java
+++ b/aswb/src/com/google/idea/blaze/android/run/runner/BlazeAndroidRunContext.java
@@ -72,7 +72,8 @@
DebugConnectorTask getDebuggerTask(
AndroidDebugger androidDebugger,
AndroidDebuggerState androidDebuggerState,
- Set<String> packageIds)
+ Set<String> packageIds,
+ boolean monitorRemoteProcess)
throws ExecutionException;
@Nullable
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/AndroidTestConsoleProvider.java b/aswb/src/com/google/idea/blaze/android/run/test/AndroidTestConsoleProvider.java
index 56ff338..d91419a 100644
--- a/aswb/src/com/google/idea/blaze/android/run/test/AndroidTestConsoleProvider.java
+++ b/aswb/src/com/google/idea/blaze/android/run/test/AndroidTestConsoleProvider.java
@@ -16,10 +16,13 @@
package com.google.idea.blaze.android.run.test;
import com.android.tools.idea.run.ConsoleProvider;
-import com.android.tools.idea.run.testing.AndroidTestConsoleProperties;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestConsoleProperties;
+import com.google.idea.blaze.android.run.test.smrunner.BlazeAndroidTestEventsHandler;
+import com.google.idea.blaze.base.run.smrunner.SmRunnerUtils;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.executors.DefaultDebugExecutor;
import com.intellij.execution.filters.TextConsoleBuilderFactory;
import com.intellij.execution.process.ProcessHandler;
import com.intellij.execution.testframework.sm.SMTestRunnerConnectionUtil;
@@ -27,37 +30,50 @@
import com.intellij.openapi.Disposable;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Disposer;
-import org.jetbrains.annotations.NotNull;
+import javax.annotation.Nullable;
/** Console provider for android_test */
class AndroidTestConsoleProvider implements ConsoleProvider {
private final Project project;
private final RunConfiguration runConfiguration;
private final BlazeAndroidTestRunConfigurationState configState;
+ @Nullable private final BlazeAndroidTestEventsHandler testEventsHandler;
AndroidTestConsoleProvider(
Project project,
RunConfiguration runConfiguration,
- BlazeAndroidTestRunConfigurationState configState) {
+ BlazeAndroidTestRunConfigurationState configState,
+ @Nullable BlazeAndroidTestEventsHandler testEventsHandler) {
this.project = project;
this.runConfiguration = runConfiguration;
this.configState = configState;
+ this.testEventsHandler = testEventsHandler;
}
- @NotNull
@Override
- public ConsoleView createAndAttach(
- @NotNull Disposable parent, @NotNull ProcessHandler handler, @NotNull Executor executor)
+ public ConsoleView createAndAttach(Disposable parent, ProcessHandler handler, Executor executor)
throws ExecutionException {
if (!configState.isRunThroughBlaze()) {
return getStockConsoleProvider().createAndAttach(parent, handler, executor);
}
- ConsoleView console =
- TextConsoleBuilderFactory.getInstance().createBuilder(project).getConsole();
+ ConsoleView console = createBlazeTestConsole(executor);
console.attachToProcess(handler);
return console;
}
+ private ConsoleView createBlazeTestConsole(Executor executor) {
+ if (testEventsHandler == null || isDebugging(executor)) {
+ // SM runner console not yet supported when debugging, because we're calling this once per
+ // test case (see ConnectBlazeTestDebuggerTask::setUpForReattachingDebugger)
+ return TextConsoleBuilderFactory.getInstance().createBuilder(project).getConsole();
+ }
+ return SmRunnerUtils.getConsoleView(project, runConfiguration, executor, testEventsHandler);
+ }
+
+ private static boolean isDebugging(Executor executor) {
+ return executor instanceof DefaultDebugExecutor;
+ }
+
private ConsoleProvider getStockConsoleProvider() {
return (parent, handler, executor) -> {
AndroidTestConsoleProperties properties =
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestClassRunConfigurationProducer.java b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestClassRunConfigurationProducer.java
index 64e8239..8d08ec0 100644
--- a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestClassRunConfigurationProducer.java
+++ b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestClassRunConfigurationProducer.java
@@ -15,8 +15,8 @@
*/
package com.google.idea.blaze.android.run.test;
-import com.android.tools.idea.run.testing.AndroidTestRunConfiguration;
import com.google.common.base.Strings;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestRunConfiguration;
import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
import com.google.idea.blaze.base.model.primitives.Kind;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestFilter.java b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestFilter.java
index c6f4a3b..e5f2b1d 100644
--- a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestFilter.java
+++ b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestFilter.java
@@ -15,8 +15,8 @@
*/
package com.google.idea.blaze.android.run.test;
-import com.android.tools.idea.run.testing.AndroidTestRunConfiguration;
import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestRunConfiguration;
import com.google.idea.blaze.base.command.BlazeFlags;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestMethodRunConfigurationProducer.java b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestMethodRunConfigurationProducer.java
index 0c42ea9..e37f07f 100644
--- a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestMethodRunConfigurationProducer.java
+++ b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestMethodRunConfigurationProducer.java
@@ -15,8 +15,8 @@
*/
package com.google.idea.blaze.android.run.test;
-import com.android.tools.idea.run.testing.AndroidTestRunConfiguration;
import com.google.common.base.Strings;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestRunConfiguration;
import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
import com.google.idea.blaze.base.model.primitives.Kind;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunConfigurationStateEditor.java b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunConfigurationStateEditor.java
index eb8293a..5df4512 100644
--- a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunConfigurationStateEditor.java
+++ b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunConfigurationStateEditor.java
@@ -16,10 +16,10 @@
package com.google.idea.blaze.android.run.test;
-import static com.android.tools.idea.run.testing.AndroidTestRunConfiguration.TEST_ALL_IN_MODULE;
-import static com.android.tools.idea.run.testing.AndroidTestRunConfiguration.TEST_ALL_IN_PACKAGE;
-import static com.android.tools.idea.run.testing.AndroidTestRunConfiguration.TEST_CLASS;
-import static com.android.tools.idea.run.testing.AndroidTestRunConfiguration.TEST_METHOD;
+import static com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestRunConfiguration.TEST_ALL_IN_MODULE;
+import static com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestRunConfiguration.TEST_ALL_IN_PACKAGE;
+import static com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestRunConfiguration.TEST_CLASS;
+import static com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestRunConfiguration.TEST_METHOD;
import com.google.idea.blaze.base.run.state.RunConfigurationState;
import com.google.idea.blaze.base.run.state.RunConfigurationStateEditor;
@@ -64,6 +64,8 @@
private JCheckBox runThroughBlazeTestCheckBox;
private final JRadioButton[] testingType2RadioButton = new JRadioButton[4];
+ private boolean componentEnabled = true;
+
BlazeAndroidTestRunConfigurationStateEditor(
RunConfigurationStateEditor commonStateEditor, Project project) {
this.commonStateEditor = commonStateEditor;
@@ -478,4 +480,29 @@
public JComponent createComponent() {
return UiUtil.createBox(commonStateEditor.createComponent(), panel);
}
+
+ @Override
+ public void setComponentEnabled(boolean enabled) {
+ componentEnabled = enabled;
+ updateEnabledState();
+ }
+
+ private void updateEnabledState() {
+ commonStateEditor.setComponentEnabled(componentEnabled);
+ allInPackageButton.setEnabled(componentEnabled);
+ classButton.setEnabled(componentEnabled);
+ testMethodButton.setEnabled(componentEnabled);
+ allInTargetButton.setEnabled(componentEnabled);
+ packageComponent.setEnabled(componentEnabled);
+ classComponent.setEnabled(componentEnabled);
+ methodComponent.setEnabled(componentEnabled);
+ runnerComponent.setEnabled(componentEnabled);
+ labelTest.setEnabled(componentEnabled);
+ runThroughBlazeTestCheckBox.setEnabled(componentEnabled);
+ for (JComponent button : testingType2RadioButton) {
+ if (button != null) {
+ button.setEnabled(componentEnabled);
+ }
+ }
+ }
}
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunConfigurationType.java b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunConfigurationType.java
deleted file mode 100644
index 2104d75..0000000
--- a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunConfigurationType.java
+++ /dev/null
@@ -1,132 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.run.test;
-
-import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
-import com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType;
-import com.google.idea.blaze.base.settings.Blaze;
-import com.intellij.execution.BeforeRunTask;
-import com.intellij.execution.configurations.ConfigurationFactory;
-import com.intellij.execution.configurations.ConfigurationType;
-import com.intellij.execution.configurations.ConfigurationTypeUtil;
-import com.intellij.execution.configurations.UnknownConfigurationType;
-import com.intellij.icons.AllIcons;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.util.Key;
-import com.intellij.ui.LayeredIcon;
-import icons.AndroidIcons;
-import javax.swing.Icon;
-import org.jetbrains.annotations.NotNull;
-
-/**
- * A type for Android test run configurations adapted specifically to run android_test targets.
- *
- * @deprecated See {@link com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType}. Retained
- * in 1.9 for legacy purposes, to allow existing BlazeAndroidTestRunConfigurations to be updated
- * to BlazeCommandRunConfigurations. Intended to be removed in 2.1.
- */
-// Hack: extend UnknownConfigurationType to completely hide it in the Run/Debug Configurations UI.
-@Deprecated
-public class BlazeAndroidTestRunConfigurationType extends UnknownConfigurationType {
- private static final Icon ANDROID_TEST_ICON;
-
- static {
- LayeredIcon icon = new LayeredIcon(2);
- icon.setIcon(AndroidIcons.Android, 0);
- icon.setIcon(AllIcons.Nodes.JunitTestMark, 1);
- ANDROID_TEST_ICON = icon;
- }
-
- private final BlazeAndroidTestRunConfigurationFactory factory =
- new BlazeAndroidTestRunConfigurationFactory(this);
-
- static class BlazeAndroidTestRunConfigurationFactory extends ConfigurationFactory {
-
- protected BlazeAndroidTestRunConfigurationFactory(@NotNull ConfigurationType type) {
- super(type);
- }
-
- @Override
- public String getName() {
- // Used to look up this ConfigurationFactory.
- // Preserve value so legacy configurations can be loaded.
- return Blaze.defaultBuildSystemName() + " Android Test";
- }
-
- @Override
- @NotNull
- public BlazeCommandRunConfiguration createTemplateConfiguration(@NotNull Project project) {
- // Create a BlazeCommandRunConfiguration instead, to update legacy configurations.
- return BlazeCommandRunConfigurationType.getInstance()
- .getFactory()
- .createTemplateConfiguration(project);
- }
-
- @Override
- public boolean canConfigurationBeSingleton() {
- return false;
- }
-
- @Override
- public boolean isApplicable(@NotNull Project project) {
- return Blaze.isBlazeProject(project);
- }
-
- @Override
- public void configureBeforeRunTaskDefaults(
- Key<? extends BeforeRunTask> providerID, BeforeRunTask task) {
- // Removed BlazeAndroidBeforeRunTaskProvider; this method won't be called anymore anyhow.
- }
-
- @Override
- public boolean isConfigurationSingletonByDefault() {
- return true;
- }
- }
-
- public static BlazeAndroidTestRunConfigurationType getInstance() {
- return ConfigurationTypeUtil.findConfigurationType(BlazeAndroidTestRunConfigurationType.class);
- }
-
- @Override
- public String getDisplayName() {
- return "Legacy " + Blaze.defaultBuildSystemName() + " Android Test";
- }
-
- @Override
- public String getConfigurationTypeDescription() {
- return "Launch/debug configuration for android_test rules "
- + "Use Blaze Command instead; this legacy configuration type is being removed.";
- }
-
- @Override
- public Icon getIcon() {
- return ANDROID_TEST_ICON;
- }
-
- @Override
- @NotNull
- public String getId() {
- // Used to look up this ConfigurationType.
- // Preserve value so legacy configurations can be loaded.
- return "BlazeAndroidTestRunConfigurationType";
- }
-
- @Override
- public BlazeAndroidTestRunConfigurationFactory[] getConfigurationFactories() {
- return new BlazeAndroidTestRunConfigurationFactory[] {factory};
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunContext.java b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunContext.java
index ee1013b..cf418e9 100644
--- a/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunContext.java
+++ b/aswb/src/com/google/idea/blaze/android/run/test/BlazeAndroidTestRunContext.java
@@ -33,6 +33,7 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.common.util.concurrent.Futures;
+import com.google.idea.blaze.android.compatibility.Compatibility;
import com.google.idea.blaze.android.run.deployinfo.BlazeAndroidDeployInfo;
import com.google.idea.blaze.android.run.deployinfo.BlazeApkProvider;
import com.google.idea.blaze.android.run.runner.BlazeAndroidDeviceSelector;
@@ -41,9 +42,13 @@
import com.google.idea.blaze.android.run.runner.BlazeAndroidRunContext;
import com.google.idea.blaze.android.run.runner.BlazeApkBuildStep;
import com.google.idea.blaze.android.run.runner.BlazeApkBuildStepNormalBuild;
+import com.google.idea.blaze.android.run.test.smrunner.BlazeAndroidTestEventsHandler;
import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.common.experiments.BoolExperiment;
import com.intellij.execution.ExecutionException;
+import com.intellij.execution.Executor;
import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.executors.DefaultDebugExecutor;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.project.Project;
import java.util.Collection;
@@ -55,6 +60,10 @@
/** Run context for android_test. */
class BlazeAndroidTestRunContext implements BlazeAndroidRunContext {
+
+ static final BoolExperiment smRunnerUiEnabled =
+ new BoolExperiment("use.smrunner.ui.android", true);
+
private final Project project;
private final AndroidFacet facet;
private final RunConfiguration runConfiguration;
@@ -82,12 +91,28 @@
this.env = env;
this.label = label;
this.configState = configState;
- this.buildFlags = buildFlags;
- this.consoleProvider = new AndroidTestConsoleProvider(project, runConfiguration, configState);
this.buildStep = new BlazeApkBuildStepNormalBuild(project, label, buildFlags);
this.applicationIdProvider =
new BlazeAndroidTestApplicationIdProvider(project, buildStep.getDeployInfo());
this.apkProvider = new BlazeApkProvider(project, buildStep.getDeployInfo());
+
+ BlazeAndroidTestEventsHandler testEventsHandler = null;
+ if (smRunnerUiEnabled.getValue() && !isDebugging(env.getExecutor())) {
+ testEventsHandler = new BlazeAndroidTestEventsHandler();
+ this.buildFlags =
+ ImmutableList.<String>builder()
+ .addAll(testEventsHandler.getBlazeFlags())
+ .addAll(buildFlags)
+ .build();
+ } else {
+ this.buildFlags = buildFlags;
+ }
+ this.consoleProvider =
+ new AndroidTestConsoleProvider(project, runConfiguration, configState, testEventsHandler);
+ }
+
+ private static boolean isDebugging(Executor executor) {
+ return executor instanceof DefaultDebugExecutor;
}
@Override
@@ -192,18 +217,26 @@
}
@Override
+ @SuppressWarnings("unchecked")
public DebugConnectorTask getDebuggerTask(
AndroidDebugger androidDebugger,
AndroidDebuggerState androidDebuggerState,
- @NotNull Set<String> packageIds)
+ @NotNull Set<String> packageIds,
+ boolean monitorRemoteProcess)
throws ExecutionException {
if (configState.isRunThroughBlaze()) {
return new ConnectBlazeTestDebuggerTask(
env.getProject(), androidDebugger, packageIds, applicationIdProvider, this);
}
- //noinspection unchecked
- return androidDebugger.getConnectDebuggerTask(
- env, null, packageIds, facet, androidDebuggerState, runConfiguration.getType().getId());
+ return Compatibility.getConnectDebuggerTask(
+ androidDebugger,
+ env,
+ null,
+ packageIds,
+ facet,
+ androidDebuggerState,
+ runConfiguration.getType().getId(),
+ monitorRemoteProcess);
}
void onLaunchTaskComplete() {
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/ConnectBlazeTestDebuggerTask.java b/aswb/src/com/google/idea/blaze/android/run/test/ConnectBlazeTestDebuggerTask.java
index 7153880..8e2328e 100644
--- a/aswb/src/com/google/idea/blaze/android/run/test/ConnectBlazeTestDebuggerTask.java
+++ b/aswb/src/com/google/idea/blaze/android/run/test/ConnectBlazeTestDebuggerTask.java
@@ -28,9 +28,9 @@
import com.android.tools.idea.run.LaunchInfo;
import com.android.tools.idea.run.ProcessHandlerConsolePrinter;
import com.android.tools.idea.run.editor.AndroidDebugger;
-import com.android.tools.idea.run.tasks.ConnectDebuggerTask;
import com.android.tools.idea.run.tasks.ConnectJavaDebuggerTask;
import com.android.tools.idea.run.util.ProcessHandlerLaunchStatus;
+import com.google.idea.blaze.android.compatibility.Compatibility.ConnectDebuggerTask;
import com.intellij.debugger.engine.RemoteDebugProcessHandler;
import com.intellij.debugger.ui.DebuggerPanelsManager;
import com.intellij.execution.ExecutionException;
@@ -62,7 +62,7 @@
Set<String> applicationIds,
ApplicationIdProvider applicationIdProvider,
BlazeAndroidTestRunContext runContext) {
- super(applicationIds, debugger, project);
+ super(applicationIds, debugger, project, true);
this.project = project;
this.applicationIdProvider = applicationIdProvider;
this.runContext = runContext;
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/StockAndroidTestLaunchTask.java b/aswb/src/com/google/idea/blaze/android/run/test/StockAndroidTestLaunchTask.java
index cf3664b..2430f3c 100644
--- a/aswb/src/com/google/idea/blaze/android/run/test/StockAndroidTestLaunchTask.java
+++ b/aswb/src/com/google/idea/blaze/android/run/test/StockAndroidTestLaunchTask.java
@@ -21,9 +21,9 @@
import com.android.tools.idea.run.ApplicationIdProvider;
import com.android.tools.idea.run.ConsolePrinter;
import com.android.tools.idea.run.tasks.LaunchTask;
-import com.android.tools.idea.run.testing.AndroidTestListener;
import com.android.tools.idea.run.util.LaunchStatus;
import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidTestListener;
import com.google.idea.blaze.android.run.deployinfo.BlazeAndroidDeployInfo;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/smrunner/BlazeAndroidTestEventsHandler.java b/aswb/src/com/google/idea/blaze/android/run/test/smrunner/BlazeAndroidTestEventsHandler.java
new file mode 100644
index 0000000..f37359a
--- /dev/null
+++ b/aswb/src/com/google/idea/blaze/android/run/test/smrunner/BlazeAndroidTestEventsHandler.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.run.test.smrunner;
+
+import com.google.idea.blaze.base.command.BlazeFlags;
+import com.google.idea.blaze.base.run.smrunner.BlazeTestEventsHandler;
+import com.google.idea.blaze.base.run.smrunner.SmRunnerUtils;
+import com.google.idea.blaze.java.run.producers.BlazeJUnitTestFilterFlags;
+import com.google.idea.blaze.java.run.producers.BlazeJUnitTestFilterFlags.JUnitVersion;
+import com.intellij.execution.Location;
+import com.intellij.execution.testframework.AbstractTestProxy;
+import com.intellij.execution.testframework.sm.runner.SMTestLocator;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiMethod;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.util.containers.MultiMap;
+import com.intellij.util.io.URLUtil;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/** Provides java-specific methods needed by the SM-runner test UI. */
+public class BlazeAndroidTestEventsHandler extends BlazeTestEventsHandler {
+
+ public BlazeAndroidTestEventsHandler() {
+ super("Blaze Android Test");
+ }
+
+ @Override
+ public SMTestLocator getTestLocator() {
+ return BlazeAndroidTestLocator.INSTANCE;
+ }
+
+ @Override
+ public String suiteLocationUrl(String name) {
+ return SmRunnerUtils.GENERIC_SUITE_PROTOCOL + URLUtil.SCHEME_SEPARATOR + name;
+ }
+
+ @Override
+ public String testLocationUrl(String name, @Nullable String className) {
+ // ignore initial value of className -- it's the test runner class.
+ name = StringUtil.trimTrailing(name, '-');
+ if (!name.contains("-")) {
+ return SmRunnerUtils.GENERIC_SUITE_PROTOCOL + URLUtil.SCHEME_SEPARATOR + name;
+ }
+ int ix = name.lastIndexOf('-');
+ className = name.substring(0, ix);
+ String methodName = name.substring(ix + 1);
+ return SmRunnerUtils.GENERIC_SUITE_PROTOCOL
+ + URLUtil.SCHEME_SEPARATOR
+ + className
+ + SmRunnerUtils.TEST_NAME_PARTS_SPLITTER
+ + methodName;
+ }
+
+ @Override
+ public String testDisplayName(String rawName) {
+ String name = StringUtil.trimTrailing(rawName, '-');
+ if (name.contains("-")) {
+ int ix = name.lastIndexOf('-');
+ return name.substring(ix + 1);
+ }
+ return name;
+ }
+
+ @Nullable
+ @Override
+ public String getTestFilter(Project project, List<AbstractTestProxy> failedTests) {
+ GlobalSearchScope projectScope = GlobalSearchScope.allScope(project);
+ MultiMap<PsiClass, PsiMethod> failedMethodsPerClass = new MultiMap<>();
+ for (AbstractTestProxy test : failedTests) {
+ appendTest(failedMethodsPerClass, test.getLocation(project, projectScope));
+ }
+ // the android test runner always runs with JUnit4
+ String filter =
+ BlazeJUnitTestFilterFlags.testFilterForClassesAndMethods(
+ failedMethodsPerClass, JUnitVersion.JUNIT_4);
+ return filter != null ? BlazeFlags.TEST_FILTER + "=" + filter : null;
+ }
+
+ private void appendTest(
+ MultiMap<PsiClass, PsiMethod> testMap, @Nullable Location<?> testLocation) {
+ if (testLocation == null) {
+ return;
+ }
+ PsiElement method = testLocation.getPsiElement();
+ if (!(method instanceof PsiMethod)) {
+ return;
+ }
+ PsiClass psiClass = ((PsiMethod) method).getContainingClass();
+ if (psiClass != null) {
+ testMap.putValue(psiClass, (PsiMethod) method);
+ }
+ }
+}
diff --git a/aswb/src/com/google/idea/blaze/android/run/test/smrunner/BlazeAndroidTestLocator.java b/aswb/src/com/google/idea/blaze/android/run/test/smrunner/BlazeAndroidTestLocator.java
new file mode 100644
index 0000000..c03f759
--- /dev/null
+++ b/aswb/src/com/google/idea/blaze/android/run/test/smrunner/BlazeAndroidTestLocator.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.run.test.smrunner;
+
+import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.base.run.smrunner.SmRunnerUtils;
+import com.intellij.execution.Location;
+import com.intellij.execution.PsiLocation;
+import com.intellij.execution.junit.JUnitUtil;
+import com.intellij.execution.testframework.sm.runner.SMTestLocator;
+import com.intellij.openapi.project.Project;
+import com.intellij.psi.JavaPsiFacade;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiMethod;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.psi.search.PsiShortNamesCache;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+
+/** Locate android test classes / methods for test UI navigation. */
+public class BlazeAndroidTestLocator implements SMTestLocator {
+
+ public static final BlazeAndroidTestLocator INSTANCE = new BlazeAndroidTestLocator();
+
+ private BlazeAndroidTestLocator() {}
+
+ @Override
+ public List<Location> getLocation(
+ String protocol, String path, Project project, GlobalSearchScope scope) {
+ if (!protocol.equals(SmRunnerUtils.GENERIC_SUITE_PROTOCOL)) {
+ return ImmutableList.of();
+ }
+ String[] split = path.split(SmRunnerUtils.TEST_NAME_PARTS_SPLITTER);
+ List<PsiClass> classes = findClasses(project, scope, split[0]);
+ if (classes.isEmpty()) {
+ return ImmutableList.of();
+ }
+ if (split.length <= 1) {
+ return classes.stream().map(PsiLocation::new).collect(Collectors.toList());
+ }
+
+ String methodName = split[1];
+ List<Location> results = new ArrayList<>();
+ for (PsiClass psiClass : classes) {
+ PsiMethod method = findTestMethod(psiClass, methodName);
+ if (method != null) {
+ results.add(new PsiLocation<>(method));
+ }
+ }
+ return results.isEmpty() ? ImmutableList.of(new PsiLocation<>(classes.get(0))) : results;
+ }
+
+ private static List<PsiClass> findClasses(
+ Project project, GlobalSearchScope scope, String className) {
+ PsiClass psiClass = JavaPsiFacade.getInstance(project).findClass(className, scope);
+ if (psiClass != null) {
+ return ImmutableList.of(psiClass);
+ }
+ // handle unqualified class names
+ return Arrays.stream(PsiShortNamesCache.getInstance(project).getClassesByName(className, scope))
+ .filter(JUnitUtil::isTestClass)
+ .collect(Collectors.toList());
+ }
+
+ private static PsiMethod findTestMethod(PsiClass psiClass, String methodName) {
+ final PsiMethod[] methods = psiClass.findMethodsByName(methodName, true);
+
+ if (methods.length == 0) {
+ return null;
+ }
+ if (methods.length == 1) {
+ return methods[0];
+ }
+ for (PsiMethod method : methods) {
+ if (method.getParameterList().getParametersCount() == 0) {
+ return method;
+ }
+ }
+ return methods[0];
+ }
+}
diff --git a/aswb/src/com/google/idea/blaze/android/settings/BlazeAndroidUserSettings.java b/aswb/src/com/google/idea/blaze/android/settings/BlazeAndroidUserSettings.java
new file mode 100644
index 0000000..6d9487b
--- /dev/null
+++ b/aswb/src/com/google/idea/blaze/android/settings/BlazeAndroidUserSettings.java
@@ -0,0 +1,54 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.settings;
+
+import com.intellij.openapi.components.PersistentStateComponent;
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.components.State;
+import com.intellij.openapi.components.Storage;
+import com.intellij.util.xmlb.XmlSerializerUtil;
+import org.jetbrains.annotations.NotNull;
+
+/** Android-specific user settings. */
+@State(name = "BlazeAndroidUserSettings", storages = @Storage("blaze.android.user.settings.xml"))
+public class BlazeAndroidUserSettings
+ implements PersistentStateComponent<BlazeAndroidUserSettings> {
+
+ private boolean useLayoutEditor = false;
+
+ public static BlazeAndroidUserSettings getInstance() {
+ return ServiceManager.getService(BlazeAndroidUserSettings.class);
+ }
+
+ @Override
+ @NotNull
+ public BlazeAndroidUserSettings getState() {
+ return this;
+ }
+
+ @Override
+ public void loadState(BlazeAndroidUserSettings state) {
+ XmlSerializerUtil.copyBean(state, this);
+ }
+
+ public boolean getUseLayoutEditor() {
+ return useLayoutEditor;
+ }
+
+ public void setUseLayoutEditor(boolean useLayoutEditor) {
+ this.useLayoutEditor = useLayoutEditor;
+ }
+}
diff --git a/aswb/src/com/google/idea/blaze/android/sync/BazelAndroidJdkProvider.java b/aswb/src/com/google/idea/blaze/android/sync/BazelAndroidJdkProvider.java
index f45b368..d603ff3 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/BazelAndroidJdkProvider.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/BazelAndroidJdkProvider.java
@@ -15,9 +15,8 @@
*/
package com.google.idea.blaze.android.sync;
-import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
-import com.intellij.openapi.project.Project;
import com.intellij.pom.java.LanguageLevel;
import javax.annotation.Nullable;
@@ -26,8 +25,11 @@
@Nullable
@Override
- public LanguageLevel getLanguageLevel(Project project) {
- BuildSystem buildSystem = Blaze.getBuildSystem(project);
- return buildSystem == BuildSystem.Bazel ? LanguageLevel.JDK_1_7 : null;
+ public LanguageLevel getLanguageLevel(
+ BuildSystem buildSystem, BlazeVersionData blazeVersionData) {
+ if (buildSystem != BuildSystem.Bazel) {
+ return null;
+ }
+ return LanguageLevel.JDK_1_7;
}
}
diff --git a/aswb/src/com/google/idea/blaze/android/sync/BlazeAndroidSyncListener.java b/aswb/src/com/google/idea/blaze/android/sync/BlazeAndroidSyncListener.java
index 815c4c9..253b4db 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/BlazeAndroidSyncListener.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/BlazeAndroidSyncListener.java
@@ -27,7 +27,7 @@
@Override
public void afterSync(
Project project, BlazeContext context, SyncMode syncMode, SyncResult syncResult) {
- if (syncResult == SyncResult.SUCCESS || syncResult == SyncResult.PARTIAL_SUCCESS) {
+ if (syncResult.successful()) {
DumbService dumbService = DumbService.getInstance(project);
dumbService.queueTask(new ResourceFolderRegistry.PopulateCachesTask(project));
}
diff --git a/aswb/src/com/google/idea/blaze/android/sync/BlazeAndroidSyncPlugin.java b/aswb/src/com/google/idea/blaze/android/sync/BlazeAndroidSyncPlugin.java
index 72b352d..74d41e7 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/BlazeAndroidSyncPlugin.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/BlazeAndroidSyncPlugin.java
@@ -15,9 +15,10 @@
*/
package com.google.idea.blaze.android.sync;
-import com.android.tools.idea.sdk.IdeSdks;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidSdkUtils;
+import com.google.idea.blaze.android.compatibility.Compatibility.IdeSdks;
import com.google.idea.blaze.android.cppapi.NdkSupport;
import com.google.idea.blaze.android.projectview.AndroidSdkPlatformSection;
import com.google.idea.blaze.android.projectview.GeneratedAndroidResourcesSection;
@@ -29,6 +30,7 @@
import com.google.idea.blaze.android.sync.sdk.AndroidSdkFromProjectView;
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.LanguageClass;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
@@ -40,6 +42,7 @@
import com.google.idea.blaze.base.scope.output.IssueOutput;
import com.google.idea.blaze.base.scope.output.StatusOutput;
import com.google.idea.blaze.base.scope.scopes.TimingScope;
+import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.sync.BlazeSyncPlugin;
import com.google.idea.blaze.base.sync.SourceFolderProvider;
import com.google.idea.blaze.base.sync.libraries.LibrarySource;
@@ -69,7 +72,6 @@
import java.util.Set;
import javax.annotation.Nullable;
import org.jetbrains.android.facet.AndroidFacet;
-import org.jetbrains.android.sdk.AndroidSdkUtils;
/** ASwB sync plugin. */
public class BlazeAndroidSyncPlugin extends BlazeSyncPlugin.Adapter {
@@ -160,6 +162,7 @@
Project project,
BlazeContext context,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
BlazeProjectData blazeProjectData) {
if (!isAndroidWorkspace(blazeProjectData.workspaceLanguageSettings)) {
return;
@@ -180,7 +183,9 @@
return;
}
- LanguageLevel defaultLanguageLevel = BuildSystemAndroidJdkProvider.languageLevel(project);
+ LanguageLevel defaultLanguageLevel =
+ BuildSystemAndroidJdkProvider.languageLevel(
+ Blaze.getBuildSystem(project), blazeVersionData);
LanguageLevel javaLanguageLevel =
JavaLanguageLevelSection.getLanguageLevel(projectViewSet, defaultLanguageLevel);
setProjectSdkAndLanguageLevel(project, sdk, javaLanguageLevel);
@@ -200,7 +205,6 @@
BlazeAndroidProjectStructureSyncer.updateProjectStructure(
project,
context,
- workspaceRoot,
projectViewSet,
blazeProjectData,
moduleEditor,
@@ -209,6 +213,23 @@
isAndroidWorkspace(blazeProjectData.workspaceLanguageSettings));
}
+ @Override
+ public void updateInMemoryState(
+ Project project,
+ BlazeContext context,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeProjectData blazeProjectData,
+ Module workspaceModule) {
+ BlazeAndroidProjectStructureSyncer.updateInMemoryState(
+ project,
+ workspaceRoot,
+ projectViewSet,
+ blazeProjectData,
+ workspaceModule,
+ isAndroidWorkspace(blazeProjectData.workspaceLanguageSettings));
+ }
+
@Nullable
@Override
public SourceFolderProvider getSourceFolderProvider(BlazeProjectData projectData) {
diff --git a/aswb/src/com/google/idea/blaze/android/sync/BuildSystemAndroidJdkProvider.java b/aswb/src/com/google/idea/blaze/android/sync/BuildSystemAndroidJdkProvider.java
index d9b53bf..94c4c9a 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/BuildSystemAndroidJdkProvider.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/BuildSystemAndroidJdkProvider.java
@@ -15,8 +15,9 @@
*/
package com.google.idea.blaze.android.sync;
+import com.google.idea.blaze.base.model.BlazeVersionData;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.intellij.openapi.extensions.ExtensionPointName;
-import com.intellij.openapi.project.Project;
import com.intellij.pom.java.LanguageLevel;
import javax.annotation.Nullable;
@@ -28,9 +29,9 @@
LanguageLevel DEFAULT_LANGUAGE_LEVEL = LanguageLevel.JDK_1_7;
- static LanguageLevel languageLevel(Project project) {
+ static LanguageLevel languageLevel(BuildSystem buildSystem, BlazeVersionData blazeVersionData) {
for (BuildSystemAndroidJdkProvider provider : EP_NAME.getExtensions()) {
- LanguageLevel level = provider.getLanguageLevel(project);
+ LanguageLevel level = provider.getLanguageLevel(buildSystem, blazeVersionData);
if (level != null) {
return level;
}
@@ -43,5 +44,5 @@
* unable to determine it.
*/
@Nullable
- LanguageLevel getLanguageLevel(Project project);
+ LanguageLevel getLanguageLevel(BuildSystem buildSystem, BlazeVersionData blazeVersionData);
}
diff --git a/aswb/src/com/google/idea/blaze/android/sync/model/AndroidResourceModuleRegistry.java b/aswb/src/com/google/idea/blaze/android/sync/model/AndroidResourceModuleRegistry.java
new file mode 100644
index 0000000..a1f6bf8
--- /dev/null
+++ b/aswb/src/com/google/idea/blaze/android/sync/model/AndroidResourceModuleRegistry.java
@@ -0,0 +1,55 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.sync.model;
+
+import com.google.common.collect.BiMap;
+import com.google.common.collect.HashBiMap;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.project.Project;
+
+/** Keeps track of which resource modules correspond to which resource target. */
+public class AndroidResourceModuleRegistry {
+ private final BiMap<Module, AndroidResourceModule> moduleMap = HashBiMap.create();
+
+ public static AndroidResourceModuleRegistry getInstance(Project project) {
+ return ServiceManager.getService(project, AndroidResourceModuleRegistry.class);
+ }
+
+ public Label getLabel(Module module) {
+ TargetKey targetKey = getTargetKey(module);
+ return targetKey == null ? null : targetKey.label;
+ }
+
+ public TargetKey getTargetKey(Module module) {
+ AndroidResourceModule resourceModule = get(module);
+ return resourceModule == null ? null : resourceModule.targetKey;
+ }
+
+ public AndroidResourceModule get(Module module) {
+ return moduleMap.get(module);
+ }
+
+ public void put(Module module, AndroidResourceModule resourceModule) {
+ moduleMap.put(module, resourceModule);
+ }
+
+ public void clear() {
+ moduleMap.clear();
+ }
+}
diff --git a/aswb/src/com/google/idea/blaze/android/sync/model/idea/BlazeAndroidModel.java b/aswb/src/com/google/idea/blaze/android/sync/model/idea/BlazeAndroidModel.java
index 7a13e1e..8e19be7 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/model/idea/BlazeAndroidModel.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/model/idea/BlazeAndroidModel.java
@@ -22,16 +22,16 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
import com.google.idea.blaze.android.manifest.ManifestParser;
-import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Computable;
import com.intellij.openapi.vfs.LocalFileSystem;
import com.intellij.openapi.vfs.VirtualFile;
import java.io.File;
import java.util.List;
import java.util.Set;
import org.jetbrains.android.dom.manifest.Manifest;
-import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/**
@@ -39,10 +39,7 @@
* user-selected build variant.
*/
public class BlazeAndroidModel implements AndroidModel {
- private static final Logger LOG = Logger.getInstance(BlazeAndroidModel.class);
-
private Project project;
- private Module module;
private final File rootDirPath;
private final SourceProvider sourceProvider;
private final List<SourceProvider> sourceProviders; // Singleton list of sourceProvider
@@ -60,7 +57,6 @@
String resourceJavaPackage,
int androidSdkApiLevel) {
this.project = project;
- this.module = module;
this.rootDirPath = rootDirPath;
this.sourceProvider = sourceProvider;
this.sourceProviders = ImmutableList.of(sourceProvider);
@@ -69,45 +65,43 @@
this.androidSdkApiLevel = androidSdkApiLevel;
}
- @NotNull
@Override
public SourceProvider getDefaultSourceProvider() {
return sourceProvider;
}
- @NotNull
@Override
public List<SourceProvider> getActiveSourceProviders() {
return sourceProviders;
}
- @NotNull
@Override
public List<SourceProvider> getTestSourceProviders() {
return sourceProviders;
}
- @NotNull
@Override
public List<SourceProvider> getAllSourceProviders() {
return sourceProviders;
}
@Override
- @NotNull
public String getApplicationId() {
- String result = null;
- Manifest manifest = ManifestParser.getInstance(project).getManifest(moduleManifest);
- if (manifest != null) {
- result = manifest.getPackage().getValue();
- }
- if (result == null) {
- result = resourceJavaPackage;
- }
- return result;
+ // Run in a read action since otherwise, it might throw a read access exception.
+ return ApplicationManager.getApplication()
+ .runReadAction(
+ (Computable<String>)
+ () -> {
+ Manifest manifest =
+ ManifestParser.getInstance(project).getManifest(moduleManifest);
+ if (manifest == null) {
+ return resourceJavaPackage;
+ }
+ String packageName = manifest.getPackage().getValue();
+ return packageName == null ? resourceJavaPackage : packageName;
+ });
}
- @NotNull
@Override
public Set<String> getAllApplicationIds() {
Set<String> applicationIds = Sets.newHashSet();
@@ -149,18 +143,16 @@
return null;
}
- @NotNull
@Override
public File getRootDirPath() {
return rootDirPath;
}
@Override
- public boolean isGenerated(@NotNull VirtualFile file) {
+ public boolean isGenerated(VirtualFile file) {
return false;
}
- @NotNull
@Override
public VirtualFile getRootDir() {
File rootDirPath = getRootDirPath();
@@ -175,14 +167,13 @@
}
@Override
- @NotNull
public ClassJarProvider getClassJarProvider() {
- return new NullClassJarProvider();
+ return new BlazeClassJarProvider(project);
}
@Override
@Nullable
- public Long getLastBuildTimestamp(@NotNull Project project) {
+ public Long getLastBuildTimestamp(Project project) {
// TODO(jvoung): Coordinate with blaze build actions to be able determine last build time.
return null;
}
diff --git a/aswb/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java b/aswb/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java
deleted file mode 100644
index dbd24d6..0000000
--- a/aswb/src/com/google/idea/blaze/android/sync/model/idea/BlazeClassJarProvider.java
+++ /dev/null
@@ -1,112 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.android.sync.model.idea;
-
-import com.android.SdkConstants;
-import com.android.tools.idea.model.ClassJarProvider;
-import com.google.idea.blaze.base.ideinfo.ArtifactLocation;
-import com.google.idea.blaze.base.ideinfo.LibraryArtifact;
-import com.google.idea.blaze.base.model.BlazeProjectData;
-import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
-import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
-import com.google.idea.blaze.java.sync.model.BlazeJarLibrary;
-import com.google.idea.blaze.java.sync.model.BlazeJavaSyncData;
-import com.intellij.openapi.module.Module;
-import com.intellij.openapi.project.Project;
-import com.intellij.openapi.vfs.JarFileSystem;
-import com.intellij.openapi.vfs.LocalFileSystem;
-import com.intellij.openapi.vfs.VirtualFile;
-import com.intellij.util.containers.OrderedSet;
-import java.io.File;
-import java.util.List;
-import org.jetbrains.annotations.Nullable;
-
-/** Collects class jars from the user's build. */
-public class BlazeClassJarProvider extends ClassJarProvider {
-
- private final Project project;
-
- public BlazeClassJarProvider(final Project project) {
- this.project = project;
- }
-
- @Override
- @Nullable
- public VirtualFile findModuleClassFile(String className, Module module) {
- BlazeProjectData blazeProjectData =
- BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
- if (blazeProjectData == null) {
- return null;
- }
- LocalFileSystem localVfs = LocalFileSystem.getInstance();
- String classNamePath = className.replace('.', File.separatorChar) + SdkConstants.DOT_CLASS;
- BlazeJavaSyncData syncData = blazeProjectData.syncState.get(BlazeJavaSyncData.class);
- if (syncData == null) {
- return null;
- }
- ArtifactLocationDecoder artifactLocationDecoder = blazeProjectData.artifactLocationDecoder;
- for (File classJar : artifactLocationDecoder.decodeAll(syncData.importResult.buildOutputJars)) {
- VirtualFile classJarVF = localVfs.findFileByIoFile(classJar);
- if (classJarVF == null) {
- continue;
- }
- VirtualFile classFile = findClassInJar(classJarVF, classNamePath);
- if (classFile != null) {
- return classFile;
- }
- }
- return null;
- }
-
- @Nullable
- private static VirtualFile findClassInJar(final VirtualFile classJar, String classNamePath) {
- VirtualFile jarRoot = JarFileSystem.getInstance().getJarRootForLocalFile(classJar);
- if (jarRoot == null) {
- return null;
- }
- return jarRoot.findFileByRelativePath(classNamePath);
- }
-
- @Override
- public List<VirtualFile> getModuleExternalLibraries(Module module) {
- OrderedSet<VirtualFile> results = new OrderedSet<VirtualFile>();
- BlazeProjectData blazeProjectData =
- BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
- if (blazeProjectData == null) {
- return results;
- }
- BlazeJavaSyncData syncData = blazeProjectData.syncState.get(BlazeJavaSyncData.class);
- if (syncData == null) {
- return null;
- }
- ArtifactLocationDecoder artifactLocationDecoder = blazeProjectData.artifactLocationDecoder;
- LocalFileSystem localVfs = LocalFileSystem.getInstance();
- for (BlazeJarLibrary blazeLibrary : syncData.importResult.libraries.values()) {
- LibraryArtifact libraryArtifact = blazeLibrary.libraryArtifact;
- ArtifactLocation classJar = libraryArtifact.classJar;
- if (classJar == null) {
- continue;
- }
- VirtualFile libVF = localVfs.findFileByIoFile(artifactLocationDecoder.decode(classJar));
- if (libVF == null) {
- continue;
- }
- results.add(libVF);
- }
-
- return results;
- }
-}
diff --git a/aswb/src/com/google/idea/blaze/android/sync/projectstructure/AndroidFacetModuleCustomizer.java b/aswb/src/com/google/idea/blaze/android/sync/projectstructure/AndroidFacetModuleCustomizer.java
index db6443a..541be52 100755
--- a/aswb/src/com/google/idea/blaze/android/sync/projectstructure/AndroidFacetModuleCustomizer.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/projectstructure/AndroidFacetModuleCustomizer.java
@@ -16,6 +16,7 @@
package com.google.idea.blaze.android.sync.projectstructure;
import com.android.builder.model.AndroidProject;
+import com.google.idea.blaze.android.compatibility.Compatibility;
import com.intellij.facet.FacetManager;
import com.intellij.facet.ModifiableFacetModel;
import com.intellij.openapi.module.Module;
@@ -55,7 +56,7 @@
private static void configureFacet(AndroidFacet facet) {
JpsAndroidModuleProperties facetState = facet.getProperties();
facetState.ALLOW_USER_CONFIGURATION = false;
- facetState.LIBRARY_PROJECT = true;
+ Compatibility.setFacetStateIsLibraryProject(facetState);
facetState.MANIFEST_FILE_RELATIVE_PATH = "";
facetState.RES_FOLDER_RELATIVE_PATH = "";
facetState.ASSETS_FOLDER_RELATIVE_PATH = "";
diff --git a/aswb/src/com/google/idea/blaze/android/sync/projectstructure/BlazeAndroidProjectStructureSyncer.java b/aswb/src/com/google/idea/blaze/android/sync/projectstructure/BlazeAndroidProjectStructureSyncer.java
index 20d5462..cd5ff8f 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/projectstructure/BlazeAndroidProjectStructureSyncer.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/projectstructure/BlazeAndroidProjectStructureSyncer.java
@@ -15,14 +15,18 @@
*/
package com.google.idea.blaze.android.sync.projectstructure;
+import static java.util.stream.Collectors.toSet;
+
import com.android.builder.model.SourceProvider;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
import com.google.common.collect.Maps;
import com.google.common.collect.Sets;
import com.google.idea.blaze.android.projectview.GeneratedAndroidResourcesSection;
import com.google.idea.blaze.android.resources.LightResourceClassService;
import com.google.idea.blaze.android.run.BlazeAndroidRunConfigurationHandler;
import com.google.idea.blaze.android.sync.model.AndroidResourceModule;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry;
import com.google.idea.blaze.android.sync.model.AndroidSdkPlatform;
import com.google.idea.blaze.android.sync.model.BlazeAndroidSyncData;
import com.google.idea.blaze.android.sync.model.idea.BlazeAndroidModel;
@@ -54,6 +58,7 @@
import com.intellij.openapi.roots.ModifiableRootModel;
import java.io.File;
import java.util.Collection;
+import java.util.List;
import java.util.Map;
import java.util.Set;
import javax.annotation.Nullable;
@@ -65,149 +70,141 @@
public static void updateProjectStructure(
Project project,
BlazeContext context,
- WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
BlazeProjectData blazeProjectData,
BlazeSyncPlugin.ModuleEditor moduleEditor,
Module workspaceModule,
ModifiableRootModel workspaceModifiableModel,
boolean isAndroidWorkspace) {
- LightResourceClassService.Builder rClassBuilder =
- new LightResourceClassService.Builder(project);
-
- if (isAndroidWorkspace) {
- BlazeAndroidSyncData syncData = blazeProjectData.syncState.get(BlazeAndroidSyncData.class);
- if (syncData == null) {
- return;
- }
-
- AndroidSdkPlatform androidSdkPlatform = syncData.androidSdkPlatform;
- if (androidSdkPlatform != null) {
- int totalOrderEntries = 0;
-
- // Create the workspace module
- updateWorkspaceModule(project, workspaceRoot, workspaceModule, androidSdkPlatform);
-
- // Create android resource modules
- // Because we're setting up dependencies, the modules have to exist before we configure them
- Map<TargetKey, AndroidResourceModule> targetToAndroidResourceModule = Maps.newHashMap();
- for (AndroidResourceModule androidResourceModule :
- syncData.importResult.androidResourceModules) {
- targetToAndroidResourceModule.put(androidResourceModule.targetKey, androidResourceModule);
- String moduleName = moduleNameForAndroidModule(androidResourceModule.targetKey);
- moduleEditor.createModule(moduleName, StdModuleTypes.JAVA);
- }
-
- // Configure android resource modules
- for (AndroidResourceModule androidResourceModule : targetToAndroidResourceModule.values()) {
- TargetIdeInfo target = blazeProjectData.targetMap.get(androidResourceModule.targetKey);
- AndroidIdeInfo androidIdeInfo = target.androidIdeInfo;
- assert androidIdeInfo != null;
-
- String moduleName = moduleNameForAndroidModule(target.key);
- Module module = moduleEditor.findModule(moduleName);
- assert module != null;
- ModifiableRootModel modifiableRootModel = moduleEditor.editModule(module);
-
- updateAndroidTargetModule(
- project,
- workspaceRoot,
- blazeProjectData.artifactLocationDecoder,
- androidSdkPlatform,
- target,
- module,
- modifiableRootModel,
- androidResourceModule);
-
- for (TargetKey resourceDependency :
- androidResourceModule.transitiveResourceDependencies) {
- if (!targetToAndroidResourceModule.containsKey(resourceDependency)) {
- continue;
- }
- String dependencyModuleName = moduleNameForAndroidModule(resourceDependency);
- Module dependency = moduleEditor.findModule(dependencyModuleName);
- if (dependency == null) {
- continue;
- }
- modifiableRootModel.addModuleOrderEntry(dependency);
- ++totalOrderEntries;
- }
- rClassBuilder.addRClass(androidIdeInfo.resourceJavaPackage, module);
- // Add a dependency from the workspace to the resource module
- workspaceModifiableModel.addModuleOrderEntry(module);
- }
-
- // Collect potential android run configuration targets
- Set<Label> runConfigurationModuleTargets = Sets.newHashSet();
-
- // Get all explicitly mentioned targets
- // Doing this now will cut down on root changes later
- for (TargetExpression targetExpression : projectViewSet.listItems(TargetSection.KEY)) {
- if (!(targetExpression instanceof Label)) {
- continue;
- }
- Label label = (Label) targetExpression;
- runConfigurationModuleTargets.add(label);
- }
- // Get any pre-existing targets
- for (RunConfiguration runConfiguration :
- RunManager.getInstance(project).getAllConfigurationsList()) {
- BlazeAndroidRunConfigurationHandler handler =
- BlazeAndroidRunConfigurationHandler.getHandlerFrom(runConfiguration);
- if (handler == null) {
- continue;
- }
- runConfigurationModuleTargets.add(handler.getLabel());
- }
-
- int totalRunConfigurationModules = 0;
- for (Label label : runConfigurationModuleTargets) {
- TargetKey targetKey = TargetKey.forPlainTarget(label);
- // If it's a resource module, it will already have been created
- if (targetToAndroidResourceModule.containsKey(targetKey)) {
- continue;
- }
- // Ensure the label is a supported android rule that exists
- TargetIdeInfo target = blazeProjectData.targetMap.get(targetKey);
- if (target == null) {
- continue;
- }
- if (!target.kindIsOneOf(Kind.ANDROID_BINARY, Kind.ANDROID_TEST)) {
- continue;
- }
-
- String moduleName = moduleNameForAndroidModule(targetKey);
- Module module = moduleEditor.createModule(moduleName, StdModuleTypes.JAVA);
- ModifiableRootModel modifiableRootModel = moduleEditor.editModule(module);
- updateAndroidTargetModule(
- project,
- workspaceRoot,
- blazeProjectData.artifactLocationDecoder,
- androidSdkPlatform,
- target,
- module,
- modifiableRootModel,
- null);
- ++totalRunConfigurationModules;
- }
-
- int whitelistedGenResources =
- projectViewSet.listItems(GeneratedAndroidResourcesSection.KEY).size();
- context.output(
- PrintOutput.log(
- String.format(
- "Android resource module count: %d, run config modules: %d, order entries: %d, "
- + "generated resources: %d",
- syncData.importResult.androidResourceModules.size(),
- totalRunConfigurationModules,
- totalOrderEntries,
- whitelistedGenResources)));
- }
- } else {
+ if (!isAndroidWorkspace) {
AndroidFacetModuleCustomizer.removeAndroidFacet(workspaceModule);
+ return;
}
- LightResourceClassService.getInstance(project).installRClasses(rClassBuilder);
+ BlazeAndroidSyncData syncData = blazeProjectData.syncState.get(BlazeAndroidSyncData.class);
+ if (syncData == null) {
+ return;
+ }
+ AndroidSdkPlatform androidSdkPlatform = syncData.androidSdkPlatform;
+ if (androidSdkPlatform == null) {
+ return;
+ }
+
+ // Configure workspace module as an android module
+ AndroidFacetModuleCustomizer.createAndroidFacet(workspaceModule);
+
+ // Create android resource modules
+ // Because we're setting up dependencies, the modules have to exist before we configure them
+ Map<TargetKey, AndroidResourceModule> targetToAndroidResourceModule = Maps.newHashMap();
+ for (AndroidResourceModule androidResourceModule :
+ syncData.importResult.androidResourceModules) {
+ targetToAndroidResourceModule.put(androidResourceModule.targetKey, androidResourceModule);
+ String moduleName = moduleNameForAndroidModule(androidResourceModule.targetKey);
+ Module module = moduleEditor.createModule(moduleName, StdModuleTypes.JAVA);
+ AndroidFacetModuleCustomizer.createAndroidFacet(module);
+ }
+
+ // Configure android resource modules
+ int totalOrderEntries = 0;
+ for (AndroidResourceModule androidResourceModule : targetToAndroidResourceModule.values()) {
+ TargetIdeInfo target = blazeProjectData.targetMap.get(androidResourceModule.targetKey);
+ AndroidIdeInfo androidIdeInfo = target.androidIdeInfo;
+ assert androidIdeInfo != null;
+
+ String moduleName = moduleNameForAndroidModule(target.key);
+ Module module = moduleEditor.findModule(moduleName);
+ assert module != null;
+ ModifiableRootModel modifiableRootModel = moduleEditor.editModule(module);
+
+ Collection<File> resources =
+ blazeProjectData.artifactLocationDecoder.decodeAll(androidResourceModule.resources);
+ ResourceModuleContentRootCustomizer.setupContentRoots(modifiableRootModel, resources);
+
+ for (TargetKey resourceDependency : androidResourceModule.transitiveResourceDependencies) {
+ if (!targetToAndroidResourceModule.containsKey(resourceDependency)) {
+ continue;
+ }
+ String dependencyModuleName = moduleNameForAndroidModule(resourceDependency);
+ Module dependency = moduleEditor.findModule(dependencyModuleName);
+ if (dependency == null) {
+ continue;
+ }
+ modifiableRootModel.addModuleOrderEntry(dependency);
+ ++totalOrderEntries;
+ }
+ // Add a dependency from the workspace to the resource module
+ workspaceModifiableModel.addModuleOrderEntry(module);
+ }
+
+ List<TargetIdeInfo> runConfigurationTargets =
+ getRunConfigurationTargets(
+ project, projectViewSet, blazeProjectData, targetToAndroidResourceModule.keySet());
+ for (TargetIdeInfo target : runConfigurationTargets) {
+ TargetKey targetKey = target.key;
+ String moduleName = moduleNameForAndroidModule(targetKey);
+ Module module = moduleEditor.createModule(moduleName, StdModuleTypes.JAVA);
+ AndroidFacetModuleCustomizer.createAndroidFacet(module);
+ }
+
+ int whitelistedGenResources =
+ projectViewSet.listItems(GeneratedAndroidResourcesSection.KEY).size();
+ context.output(
+ PrintOutput.log(
+ String.format(
+ "Android resource module count: %d, run config modules: %d, order entries: %d, "
+ + "generated resources: %d",
+ syncData.importResult.androidResourceModules.size(),
+ runConfigurationTargets.size(),
+ totalOrderEntries,
+ whitelistedGenResources)));
+ }
+
+ // Collect potential android run configuration targets
+ private static List<TargetIdeInfo> getRunConfigurationTargets(
+ Project project,
+ ProjectViewSet projectViewSet,
+ BlazeProjectData blazeProjectData,
+ Set<TargetKey> androidResourceModules) {
+ List<TargetIdeInfo> result = Lists.newArrayList();
+ Set<Label> runConfigurationModuleTargets = Sets.newHashSet();
+
+ // Get all explicitly mentioned targets
+ // Doing this now will cut down on root changes later
+ for (TargetExpression targetExpression : projectViewSet.listItems(TargetSection.KEY)) {
+ if (!(targetExpression instanceof Label)) {
+ continue;
+ }
+ Label label = (Label) targetExpression;
+ runConfigurationModuleTargets.add(label);
+ }
+ // Get any pre-existing targets
+ for (RunConfiguration runConfiguration :
+ RunManager.getInstance(project).getAllConfigurationsList()) {
+ BlazeAndroidRunConfigurationHandler handler =
+ BlazeAndroidRunConfigurationHandler.getHandlerFrom(runConfiguration);
+ if (handler == null) {
+ continue;
+ }
+ runConfigurationModuleTargets.add(handler.getLabel());
+ }
+
+ for (Label label : runConfigurationModuleTargets) {
+ TargetKey targetKey = TargetKey.forPlainTarget(label);
+ // If it's a resource module, it will already have been created
+ if (androidResourceModules.contains(targetKey)) {
+ continue;
+ }
+ // Ensure the label is a supported android rule that exists
+ TargetIdeInfo target = blazeProjectData.targetMap.get(targetKey);
+ if (target == null) {
+ continue;
+ }
+ if (!target.kindIsOneOf(Kind.ANDROID_BINARY, Kind.ANDROID_TEST)) {
+ continue;
+ }
+ result.add(target);
+ }
+ return result;
}
/** Ensures a suitable module exists for the given android target. */
@@ -220,7 +217,6 @@
return module;
}
- WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
BlazeProjectData blazeProjectData =
BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
if (blazeProjectData == null) {
@@ -246,20 +242,10 @@
BlazeSyncPlugin.ModuleEditor moduleEditor =
BlazeProjectDataManager.getInstance(project).editModules();
Module newModule = moduleEditor.createModule(moduleName, StdModuleTypes.JAVA);
- ModifiableRootModel modifiableRootModel = moduleEditor.editModule(newModule);
-
ApplicationManager.getApplication()
.runWriteAction(
() -> {
- updateAndroidTargetModule(
- project,
- workspaceRoot,
- blazeProjectData.artifactLocationDecoder,
- androidSdkPlatform,
- target,
- newModule,
- modifiableRootModel,
- null);
+ AndroidFacetModuleCustomizer.createAndroidFacet(newModule);
moduleEditor.commit();
});
return newModule;
@@ -273,8 +259,122 @@
.replace(':', '.');
}
+ public static void updateInMemoryState(
+ Project project,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeProjectData blazeProjectData,
+ Module workspaceModule,
+ boolean isAndroidWorkspace) {
+ LightResourceClassService.Builder rClassBuilder =
+ new LightResourceClassService.Builder(project);
+ AndroidResourceModuleRegistry registry = AndroidResourceModuleRegistry.getInstance(project);
+ registry.clear();
+ if (isAndroidWorkspace) {
+ updateInMemoryState(
+ project,
+ workspaceRoot,
+ projectViewSet,
+ blazeProjectData,
+ workspaceModule,
+ registry,
+ rClassBuilder);
+ }
+ LightResourceClassService.getInstance(project).installRClasses(rClassBuilder);
+ }
+
+ private static void updateInMemoryState(
+ Project project,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeProjectData blazeProjectData,
+ Module workspaceModule,
+ AndroidResourceModuleRegistry registry,
+ LightResourceClassService.Builder rClassBuilder) {
+ BlazeAndroidSyncData syncData = blazeProjectData.syncState.get(BlazeAndroidSyncData.class);
+ if (syncData == null) {
+ return;
+ }
+ AndroidSdkPlatform androidSdkPlatform = syncData.androidSdkPlatform;
+ if (androidSdkPlatform == null) {
+ return;
+ }
+
+ updateWorkspaceModuleFacetInMemoryState(
+ project, workspaceRoot, workspaceModule, androidSdkPlatform);
+
+ ArtifactLocationDecoder artifactLocationDecoder = blazeProjectData.artifactLocationDecoder;
+ ModuleManager moduleManager = ModuleManager.getInstance(project);
+ for (AndroidResourceModule androidResourceModule :
+ syncData.importResult.androidResourceModules) {
+ TargetIdeInfo target = blazeProjectData.targetMap.get(androidResourceModule.targetKey);
+ String moduleName = moduleNameForAndroidModule(target.key);
+ Module module = moduleManager.findModuleByName(moduleName);
+ registry.put(module, androidResourceModule);
+
+ AndroidIdeInfo androidIdeInfo = target.androidIdeInfo;
+ assert androidIdeInfo != null;
+
+ updateModuleFacetInMemoryState(
+ project,
+ androidSdkPlatform,
+ module,
+ moduleDirectoryForAndroidTarget(workspaceRoot, target),
+ manifestFileForAndroidTarget(
+ artifactLocationDecoder,
+ androidIdeInfo,
+ moduleDirectoryForAndroidTarget(workspaceRoot, target)),
+ androidIdeInfo.resourceJavaPackage,
+ artifactLocationDecoder.decodeAll(androidResourceModule.transitiveResources));
+ rClassBuilder.addRClass(androidIdeInfo.resourceJavaPackage, module);
+ }
+
+ Set<TargetKey> androidResourceModules =
+ syncData
+ .importResult
+ .androidResourceModules
+ .stream()
+ .map(androidResourceModule -> androidResourceModule.targetKey)
+ .collect(toSet());
+ List<TargetIdeInfo> runConfigurationTargets =
+ getRunConfigurationTargets(
+ project, projectViewSet, blazeProjectData, androidResourceModules);
+ for (TargetIdeInfo target : runConfigurationTargets) {
+ String moduleName = moduleNameForAndroidModule(target.key);
+ Module module = moduleManager.findModuleByName(moduleName);
+ AndroidIdeInfo androidIdeInfo = target.androidIdeInfo;
+ assert androidIdeInfo != null;
+ updateModuleFacetInMemoryState(
+ project,
+ androidSdkPlatform,
+ module,
+ moduleDirectoryForAndroidTarget(workspaceRoot, target),
+ manifestFileForAndroidTarget(
+ artifactLocationDecoder,
+ androidIdeInfo,
+ moduleDirectoryForAndroidTarget(workspaceRoot, target)),
+ androidIdeInfo.resourceJavaPackage,
+ ImmutableList.of());
+ }
+ }
+
+ private static File moduleDirectoryForAndroidTarget(
+ WorkspaceRoot workspaceRoot, TargetIdeInfo target) {
+ return workspaceRoot.fileForPath(target.key.label.blazePackage());
+ }
+
+ private static File manifestFileForAndroidTarget(
+ ArtifactLocationDecoder artifactLocationDecoder,
+ AndroidIdeInfo androidIdeInfo,
+ File moduleDirectory) {
+ ArtifactLocation manifestArtifactLocation = androidIdeInfo.manifest;
+ return manifestArtifactLocation != null
+ ? artifactLocationDecoder.decode(manifestArtifactLocation)
+ : new File(moduleDirectory, "AndroidManifest.xml");
+ }
+
/** Updates the shared workspace module with android info. */
- private static void updateWorkspaceModule(
+ private static void updateWorkspaceModuleFacetInMemoryState(
Project project,
WorkspaceRoot workspaceRoot,
Module workspaceModule,
@@ -283,8 +383,7 @@
File manifest = new File(workspaceRoot.directory(), "AndroidManifest.xml");
String resourceJavaPackage = ":workspace";
ImmutableList<File> transitiveResources = ImmutableList.of();
-
- createAndroidModel(
+ updateModuleFacetInMemoryState(
project,
androidSdkPlatform,
workspaceModule,
@@ -294,49 +393,7 @@
transitiveResources);
}
- /** Updates a module from an android rule. */
- private static void updateAndroidTargetModule(
- Project project,
- WorkspaceRoot workspaceRoot,
- ArtifactLocationDecoder artifactLocationDecoder,
- AndroidSdkPlatform androidSdkPlatform,
- TargetIdeInfo target,
- Module module,
- ModifiableRootModel modifiableRootModel,
- @Nullable AndroidResourceModule androidResourceModule) {
-
- Collection<File> resources =
- androidResourceModule != null
- ? artifactLocationDecoder.decodeAll(androidResourceModule.resources)
- : ImmutableList.of();
- Collection<File> transitiveResources =
- androidResourceModule != null
- ? artifactLocationDecoder.decodeAll(androidResourceModule.transitiveResources)
- : ImmutableList.of();
-
- AndroidIdeInfo androidIdeInfo = target.androidIdeInfo;
- assert androidIdeInfo != null;
-
- File moduleDirectory = workspaceRoot.fileForPath(target.key.label.blazePackage());
- ArtifactLocation manifestArtifactLocation = androidIdeInfo.manifest;
- File manifest =
- manifestArtifactLocation != null
- ? artifactLocationDecoder.decode(manifestArtifactLocation)
- : new File(moduleDirectory, "AndroidManifest.xml");
- String resourceJavaPackage = androidIdeInfo.resourceJavaPackage;
- ResourceModuleContentRootCustomizer.setupContentRoots(modifiableRootModel, resources);
-
- createAndroidModel(
- project,
- androidSdkPlatform,
- module,
- moduleDirectory,
- manifest,
- resourceJavaPackage,
- transitiveResources);
- }
-
- private static void createAndroidModel(
+ private static void updateModuleFacetInMemoryState(
Project project,
AndroidSdkPlatform androidSdkPlatform,
Module module,
@@ -344,7 +401,6 @@
File manifest,
String resourceJavaPackage,
Collection<File> transitiveResources) {
- AndroidFacetModuleCustomizer.createAndroidFacet(module);
SourceProvider sourceProvider =
new SourceProviderImpl(module.getName(), manifest, transitiveResources);
BlazeAndroidModel androidModel =
diff --git a/aswb/src/com/google/idea/blaze/android/sync/sdk/AndroidSdkFromProjectView.java b/aswb/src/com/google/idea/blaze/android/sync/sdk/AndroidSdkFromProjectView.java
index 05b52e4..e4ae1b5 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/sdk/AndroidSdkFromProjectView.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/sdk/AndroidSdkFromProjectView.java
@@ -17,6 +17,7 @@
import com.google.common.base.Joiner;
import com.google.common.collect.Lists;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidSdkUtils;
import com.google.idea.blaze.android.projectview.AndroidSdkPlatformSection;
import com.google.idea.blaze.android.sync.model.AndroidSdkPlatform;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
@@ -29,7 +30,6 @@
import javax.annotation.Nullable;
import org.jetbrains.android.sdk.AndroidPlatform;
import org.jetbrains.android.sdk.AndroidSdkAdditionalData;
-import org.jetbrains.android.sdk.AndroidSdkUtils;
/** Calculates AndroidSdkPlatform. */
public class AndroidSdkFromProjectView {
diff --git a/aswb/src/com/google/idea/blaze/android/sync/sdk/SdkUtil.java b/aswb/src/com/google/idea/blaze/android/sync/sdk/SdkUtil.java
index 933679d..fcbe1f9 100644
--- a/aswb/src/com/google/idea/blaze/android/sync/sdk/SdkUtil.java
+++ b/aswb/src/com/google/idea/blaze/android/sync/sdk/SdkUtil.java
@@ -16,6 +16,7 @@
package com.google.idea.blaze.android.sync.sdk;
import com.android.tools.idea.updater.configure.SdkUpdaterConfigurableProvider;
+import com.google.idea.blaze.android.compatibility.Compatibility.AndroidSdkUtils;
import com.google.idea.blaze.android.sync.model.AndroidSdkPlatform;
import com.google.idea.blaze.android.sync.model.BlazeAndroidSyncData;
import com.google.idea.blaze.base.model.BlazeProjectData;
@@ -26,7 +27,6 @@
import com.intellij.openapi.project.Project;
import com.intellij.openapi.projectRoots.Sdk;
import org.jetbrains.android.sdk.AndroidPlatform;
-import org.jetbrains.android.sdk.AndroidSdkUtils;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
diff --git a/aswb/tests/integrationtests/com/google/idea/blaze/android/run/BlazeAndroidRunConfigurationCommonStateMigrationTest.java b/aswb/tests/integrationtests/com/google/idea/blaze/android/run/BlazeAndroidRunConfigurationCommonStateMigrationTest.java
index 0a222a7..7eca0c6 100644
--- a/aswb/tests/integrationtests/com/google/idea/blaze/android/run/BlazeAndroidRunConfigurationCommonStateMigrationTest.java
+++ b/aswb/tests/integrationtests/com/google/idea/blaze/android/run/BlazeAndroidRunConfigurationCommonStateMigrationTest.java
@@ -90,58 +90,6 @@
}
@Test
- public void readAndWriteShouldMigrate() throws Exception {
- String oldXml =
- "<?xml version=\"1.0\"?>"
- + "<configuration blaze-native-debug=\"true\">"
- + " <blaze-user-flag>--flag1</blaze-user-flag>"
- + " <blaze-user-flag>--flag2</blaze-user-flag>"
- + " <option name=\"USE_LAST_SELECTED_DEVICE\" value=\"true\" />"
- + " <option name=\"PREFERRED_AVD\" value=\"some avd\" />"
- + DEBUGGER_STATE_AUTO_RAW_XML
- + DEBUGGER_STATE_NATIVE_RAW_XML
- + DEBUGGER_STATE_JAVA_RAW_XML
- + DEBUGGER_STATE_HYBRID_RAW_XML
- + DEBUGGER_STATE_BLAZE_AUTO_RAW_XML
- + "</configuration>";
- Element oldElement = saxBuilder.build(new StringReader(oldXml)).getRootElement();
-
- state.readExternal(oldElement);
- Element migratedElement = new Element("configuration");
- state.writeExternal(migratedElement);
-
- assertThat(migratedElement.getChildren()).hasSize(4);
- assertThat(migratedElement.getAttribute("blaze-native-debug").getValue()).isEqualTo("true");
-
- List<Element> flagElements = migratedElement.getChildren("blaze-user-flag");
- assertThat(flagElements).hasSize(2);
- assertThat(flagElements.get(0).getText()).isEqualTo("--flag1");
- assertThat(flagElements.get(1).getText()).isEqualTo("--flag2");
-
- Element deployTargetStatesElement = migratedElement.getChild("android-deploy-target-states");
- assertThat(xmlOutputter.outputString(deployTargetStatesElement))
- .isEqualTo(formatRawXml(DEPLOY_TARGET_STATES_RAW_XML));
-
- Element debuggerStatesElement = migratedElement.getChild("android-debugger-states");
- assertThat(debuggerStatesElement.getChildren()).hasSize(5);
- Element debuggerStateElement = debuggerStatesElement.getChild("Auto");
- assertThat(xmlOutputter.outputString(debuggerStateElement))
- .isEqualTo(formatRawXml(DEBUGGER_STATE_AUTO_RAW_XML));
- debuggerStateElement = debuggerStatesElement.getChild("Native");
- assertThat(xmlOutputter.outputString(debuggerStateElement))
- .isEqualTo(formatRawXml(DEBUGGER_STATE_NATIVE_RAW_XML));
- debuggerStateElement = debuggerStatesElement.getChild("Java");
- assertThat(xmlOutputter.outputString(debuggerStateElement))
- .isEqualTo(formatRawXml(DEBUGGER_STATE_JAVA_RAW_XML));
- debuggerStateElement = debuggerStatesElement.getChild("Hybrid");
- assertThat(xmlOutputter.outputString(debuggerStateElement))
- .isEqualTo(formatRawXml(DEBUGGER_STATE_HYBRID_RAW_XML));
- debuggerStateElement = debuggerStatesElement.getChild("BlazeAuto");
- assertThat(xmlOutputter.outputString(debuggerStateElement))
- .isEqualTo(formatRawXml(DEBUGGER_STATE_BLAZE_AUTO_RAW_XML));
- }
-
- @Test
public void readAndWriteShouldRemoveExtraElements() throws Exception {
String oldXml =
"<?xml version=\"1.0\"?>"
diff --git a/aswb/tests/integrationtests/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationStateTest.java b/aswb/tests/integrationtests/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationStateTest.java
index 76cd2e5..05de9a5 100644
--- a/aswb/tests/integrationtests/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationStateTest.java
+++ b/aswb/tests/integrationtests/com/google/idea/blaze/android/run/binary/BlazeAndroidBinaryRunConfigurationStateTest.java
@@ -63,7 +63,6 @@
state.setMode(BlazeAndroidBinaryRunConfigurationState.LAUNCH_SPECIFIC_ACTIVITY);
state.setMobileInstall(true);
state.setUseSplitApksIfPossible(false);
- state.setInstantRun(true);
state.setUseWorkProfileIfPresent(true);
state.setUserId(2);
state.setDeepLink("http://deeplink");
@@ -83,7 +82,6 @@
.isEqualTo(BlazeAndroidBinaryRunConfigurationState.LAUNCH_SPECIFIC_ACTIVITY);
assertThat(readState.mobileInstall()).isTrue();
assertThat(readState.useSplitApksIfPossible()).isFalse();
- assertThat(readState.instantRun()).isTrue();
assertThat(readState.useWorkProfileIfPresent()).isTrue();
assertThat(readState.getUserId()).isEqualTo(2);
assertThat(readState.getDeepLink()).isEqualTo("http://deeplink");
@@ -107,7 +105,6 @@
assertThat(readState.getMode()).isEqualTo(state.getMode());
assertThat(readState.mobileInstall()).isEqualTo(state.mobileInstall());
assertThat(readState.useSplitApksIfPossible()).isEqualTo(state.useSplitApksIfPossible());
- assertThat(readState.instantRun()).isEqualTo(state.instantRun());
assertThat(readState.useWorkProfileIfPresent()).isEqualTo(state.useWorkProfileIfPresent());
assertThat(readState.getUserId()).isEqualTo(state.getUserId());
assertThat(readState.getDeepLink()).isEqualTo(state.getDeepLink());
@@ -125,7 +122,6 @@
state.setMode(BlazeAndroidBinaryRunConfigurationState.LAUNCH_SPECIFIC_ACTIVITY);
state.setMobileInstall(true);
state.setUseSplitApksIfPossible(false);
- state.setInstantRun(true);
state.setUseWorkProfileIfPresent(true);
state.setUserId(2);
state.setDeepLink("http://deeplink");
@@ -151,7 +147,6 @@
state.setMode(BlazeAndroidBinaryRunConfigurationState.LAUNCH_SPECIFIC_ACTIVITY);
state.setMobileInstall(true);
state.setUseSplitApksIfPossible(false);
- state.setInstantRun(true);
state.setUseWorkProfileIfPresent(true);
state.setUserId(2);
// We don't test DeepLink because it is not exposed in the editor.
@@ -171,7 +166,6 @@
assertThat(readState.getMode()).isEqualTo(state.getMode());
assertThat(readState.mobileInstall()).isEqualTo(state.mobileInstall());
assertThat(readState.useSplitApksIfPossible()).isEqualTo(state.useSplitApksIfPossible());
- assertThat(readState.instantRun()).isEqualTo(state.instantRun());
assertThat(readState.useWorkProfileIfPresent()).isEqualTo(state.useWorkProfileIfPresent());
assertThat(readState.getUserId()).isEqualTo(state.getUserId());
// We don't test DeepLink because it is not exposed in the editor.
@@ -197,7 +191,6 @@
assertThat(readState.getMode()).isEqualTo(state.getMode());
assertThat(readState.mobileInstall()).isEqualTo(state.mobileInstall());
assertThat(readState.useSplitApksIfPossible()).isEqualTo(state.useSplitApksIfPossible());
- assertThat(readState.instantRun()).isEqualTo(state.instantRun());
assertThat(readState.useWorkProfileIfPresent()).isEqualTo(state.useWorkProfileIfPresent());
assertThat(readState.getUserId()).isEqualTo(state.getUserId());
// We don't test DeepLink because it is not exposed in the editor.
diff --git a/aswb/tests/unittests/com/google/idea/blaze/android/sync/importer/model/idea/AndroidResourceModuleRegistryTest.java b/aswb/tests/unittests/com/google/idea/blaze/android/sync/importer/model/idea/AndroidResourceModuleRegistryTest.java
new file mode 100644
index 0000000..9a8e66c
--- /dev/null
+++ b/aswb/tests/unittests/com/google/idea/blaze/android/sync/importer/model/idea/AndroidResourceModuleRegistryTest.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright 2016 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.idea.blaze.android.sync.importer.model.idea;
+
+import static com.google.common.truth.Truth.THROW_ASSERTION_ERROR;
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.mock;
+
+import com.google.idea.blaze.android.sync.model.AndroidResourceModule;
+import com.google.idea.blaze.android.sync.model.AndroidResourceModuleRegistry;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.intellij.openapi.module.Module;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link AndroidResourceModuleRegistry}. */
+@RunWith(JUnit4.class)
+public class AndroidResourceModuleRegistryTest extends BlazeTestCase {
+ private AndroidResourceModuleRegistry registry;
+
+ @Override
+ protected void initTest(
+ @NotNull Container applicationServices, @NotNull Container projectServices) {
+ super.initTest(applicationServices, projectServices);
+ projectServices.register(
+ AndroidResourceModuleRegistry.class, new AndroidResourceModuleRegistry());
+
+ registry = AndroidResourceModuleRegistry.getInstance(getProject());
+ }
+
+ @Test
+ public void testPutAndGet() {
+ Module moduleOne = mock(Module.class);
+ Module moduleTwo = mock(Module.class);
+ Module moduleThree = mock(Module.class);
+ AndroidResourceModule resourceModuleOne =
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(new Label("//foo/bar:one"))).build();
+ AndroidResourceModule resourceModuleTwo =
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(new Label("//foo/bar:two"))).build();
+ AndroidResourceModule resourceModuleThree =
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(new Label("//foo/bar:three")))
+ .build();
+ registry.put(moduleOne, resourceModuleOne);
+ registry.put(moduleTwo, resourceModuleTwo);
+ registry.put(moduleThree, resourceModuleThree);
+
+ assertThat(registry.get(moduleOne)).isEqualTo(resourceModuleOne);
+ assertThat(registry.get(moduleTwo)).isEqualTo(resourceModuleTwo);
+ assertThat(registry.get(moduleThree)).isEqualTo(resourceModuleThree);
+ assertThat(registry.getTargetKey(moduleOne)).isEqualTo(resourceModuleOne.targetKey);
+ assertThat(registry.getTargetKey(moduleTwo)).isEqualTo(resourceModuleTwo.targetKey);
+ assertThat(registry.getTargetKey(moduleThree)).isEqualTo(resourceModuleThree.targetKey);
+ assertThat(registry.getLabel(moduleOne)).isEqualTo(resourceModuleOne.targetKey.label);
+ assertThat(registry.getLabel(moduleTwo)).isEqualTo(resourceModuleTwo.targetKey.label);
+ assertThat(registry.getLabel(moduleThree)).isEqualTo(resourceModuleThree.targetKey.label);
+ }
+
+ @Test
+ public void testPutSameKeyDifferentValues() {
+ Module module = mock(Module.class);
+ AndroidResourceModule resourceModuleOne =
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(new Label("//foo/bar:one"))).build();
+ AndroidResourceModule resourceModuleTwo =
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(new Label("//foo/bar:two"))).build();
+ registry.put(module, resourceModuleOne);
+ registry.put(module, resourceModuleTwo);
+ assertThat(registry.get(module)).isEqualTo(resourceModuleTwo);
+ }
+
+ @Test
+ public void testPutDifferentKeysSameValue() {
+ Module moduleOne = mock(Module.class);
+ Module moduleTwo = mock(Module.class);
+ AndroidResourceModule resourceModule =
+ AndroidResourceModule.builder(TargetKey.forPlainTarget(new Label("//foo/bar:one"))).build();
+ registry.put(moduleOne, resourceModule);
+ try {
+ registry.put(moduleTwo, resourceModule);
+ THROW_ASSERTION_ERROR.fail("Expected IllegalArgumentException");
+ } catch (IllegalArgumentException ignored) {
+ // ignored
+ }
+ assertThat(registry.get(moduleOne)).isEqualTo(resourceModule);
+ assertThat(registry.get(moduleTwo)).isNull();
+ }
+
+ @Test
+ public void testGetNull() {
+ assertThat(registry.get(null)).isNull();
+ assertThat(registry.getTargetKey(null)).isNull();
+ assertThat(registry.getLabel(null)).isNull();
+ }
+
+ @Test
+ public void testGetWithoutPut() {
+ assertThat(registry.get(mock(Module.class))).isNull();
+ assertThat(registry.getTargetKey(mock(Module.class))).isNull();
+ assertThat(registry.getLabel(mock(Module.class))).isNull();
+ }
+}
diff --git a/base/BUILD b/base/BUILD
index 6902fd5..850f1dd 100644
--- a/base/BUILD
+++ b/base/BUILD
@@ -6,11 +6,13 @@
resources = glob(["resources/**/*"]),
visibility = ["//visibility:public"],
deps = [
+ "//common/actionhelper",
"//common/binaryhelper",
"//common/experiments",
"//common/formatter",
"//intellij_platform_sdk:plugin_api",
"//proto_deps",
+ "//sdkcompat",
"@jsr305_annotations//jar",
],
)
@@ -29,6 +31,7 @@
deps = [
"//base",
"//intellij_platform_sdk:plugin_api_for_tests",
+ "//sdkcompat",
"@jsr305_annotations//jar",
"@junit//jar",
],
diff --git a/base/src/META-INF/blaze-base.xml b/base/src/META-INF/blaze-base.xml
index 1e12599..34d33f4 100644
--- a/base/src/META-INF/blaze-base.xml
+++ b/base/src/META-INF/blaze-base.xml
@@ -15,46 +15,86 @@
-->
<idea-plugin>
<actions>
- <action id="MakeBlazeProject" class="com.google.idea.blaze.base.actions.BlazeMakeProjectAction" use-shortcut-of="CompileDirty" icon="AllIcons.Actions.Compile">
+ <action id="MakeBlazeProject"
+ class="com.google.idea.blaze.base.actions.BlazeMakeProjectAction"
+ text="Compile Project"
+ use-shortcut-of="CompileDirty"
+ icon="AllIcons.Actions.Compile">
</action>
- <action id="MakeBlazeModule" class="com.google.idea.blaze.base.actions.BlazeCompileFileAction">
+ <action id="MakeBlazeModule"
+ class="com.google.idea.blaze.base.actions.BlazeCompileFileAction"
+ text="Compile File">
</action>
- <action id="Blaze.IncrementalSyncProject" class="com.google.idea.blaze.base.sync.actions.IncrementalSyncProjectAction" icon="BlazeIcons.Blaze">
+ <action id="Blaze.IncrementalSyncProject"
+ class="com.google.idea.blaze.base.sync.actions.IncrementalSyncProjectAction"
+ text="Sync Project with BUILD Files"
+ icon="BlazeIcons.Blaze">
</action>
- <action id="Blaze.FullSyncProject" class="com.google.idea.blaze.base.sync.actions.FullSyncProjectAction" icon="BlazeIcons.BlazeSlow">
+ <action id="Blaze.FullSyncProject"
+ class="com.google.idea.blaze.base.sync.actions.FullSyncProjectAction"
+ text="Non-Incrementally Sync Project with BUILD Files"
+ icon="BlazeIcons.BlazeSlow">
</action>
- <action id="Blaze.SyncWorkingSet" class="com.google.idea.blaze.base.sync.actions.SyncWorkingSetAction" icon="BlazeIcons.Blaze" text="Sync Working Set">
+ <action id="Blaze.SyncWorkingSet"
+ class="com.google.idea.blaze.base.sync.actions.SyncWorkingSetAction"
+ text="Sync Working Set"
+ icon="BlazeIcons.Blaze">
</action>
- <action id="Blaze.ExpandSyncToWorkingSet" class="com.google.idea.blaze.base.sync.actions.ExpandSyncToWorkingSetAction" text="Expand Sync to Working Set">
+ <action id="Blaze.ExpandSyncToWorkingSet"
+ class="com.google.idea.blaze.base.sync.actions.ExpandSyncToWorkingSetAction"
+ text="Expand Sync to Working Set">
</action>
- <action id="Blaze.ShowPerformanceWarnings" class="com.google.idea.blaze.base.sync.actions.ShowPerformanceWarningsToggleAction" text="Show Performance Warnings">
+ <action id="Blaze.ShowPerformanceWarnings"
+ class="com.google.idea.blaze.base.sync.actions.ShowPerformanceWarningsToggleAction"
+ text="Show Performance Warnings">
</action>
- <action id="Blaze.EditProjectView" class="com.google.idea.blaze.base.settings.ui.EditProjectViewAction" text="Edit Project View..." icon="BlazeIcons.Blaze">
+ <action id="Blaze.EditProjectView"
+ class="com.google.idea.blaze.base.settings.ui.EditProjectViewAction"
+ text="Open Project View Files">
</action>
-
<action class="com.google.idea.blaze.base.buildmap.OpenCorrespondingBuildFile"
- id="Blaze.OpenCorrespondingBuildFile"
- icon="BlazeIcons.Blaze"
- text="Open Corresponding BUILD File">
+ id="Blaze.OpenCorrespondingBuildFile"
+ text="Open Corresponding BUILD File">
</action>
<action class="com.google.idea.blaze.base.sync.actions.PartialSyncAction"
- id="Blaze.PartialSync"
- icon="BlazeIcons.Blaze">
+ id="Blaze.PartialSync"
+ text="Partially Sync File"
+ icon="BlazeIcons.Blaze">
</action>
+ <action id="Blaze.ExportRunConfigurations"
+ class="com.google.idea.blaze.base.run.exporter.ExportRunConfigurationAction"
+ text="Export Run Configurations"
+ icon="AllIcons.Actions.Export">
+ </action>
+ <action id="Blaze.NewPackageAction"
+ class="com.google.idea.blaze.base.ide.NewBlazePackageAction"
+ text="New Package"/>
+ <action id="Blaze.NewRuleAction"
+ class="com.google.idea.blaze.base.ide.NewBlazeRuleAction"
+ text="New Rule"
+ popup="true"/>
<group id="Blaze.MainMenuActionGroup" class="com.google.idea.blaze.base.actions.BlazeMenuGroup">
<add-to-group group-id="MainMenu" anchor="before" relative-to-action="HelpMenu"/>
- <reference id="MakeBlazeProject"/>
- <reference id="MakeBlazeModule"/>
- <separator/>
<reference id="Blaze.EditProjectView"/>
+ <group id ="Blaze.SyncMenuGroup" text="Sync" popup="true">
+ <reference id="Blaze.IncrementalSyncProject"/>
+ <reference id="Blaze.FullSyncProject"/>
+ <reference id="Blaze.SyncWorkingSet"/>
+ <reference id="Blaze.PartialSync"/>
+ <reference id="Blaze.ExpandSyncToWorkingSet"/>
+ <reference id="Blaze.ShowPerformanceWarnings"/>
+ </group>
+ <group id="Blaze.BuildMenuGroup" text="Build" popup="true">
+ <reference id="MakeBlazeProject"/>
+ <reference id="MakeBlazeModule"/>
+ </group>
+ <!--Add popup groups anchored after this bookmark-->
+ <group id="Blaze.MenuGroupsBookmark"/>
<separator/>
- <reference id="Blaze.IncrementalSyncProject"/>
- <reference id="Blaze.FullSyncProject"/>
- <reference id="Blaze.SyncWorkingSet"/>
- <reference id="Blaze.PartialSync"/>
- <reference id="Blaze.ExpandSyncToWorkingSet"/>
- <reference id="Blaze.ShowPerformanceWarnings"/>
+ <reference id="Blaze.ExportRunConfigurations"/>
+ <!--Add single menu items anchored after this bookmark-->
+ <group id="Blaze.MenuFooter"/>
</group>
<group id="Blaze.MainToolBarActionGroup">
@@ -65,8 +105,8 @@
<group id="Blaze.NewActions" text="Edit Blaze structure" description="Create new Blaze packages, rules, etc.">
<add-to-group group-id="NewGroup" anchor="first"/>
- <action id="Blaze.NewPackageAction" class="com.google.idea.blaze.base.ide.NewBlazePackageAction" popup="true"/>
- <action id="Blaze.NewRuleAction" class="com.google.idea.blaze.base.ide.NewBlazeRuleAction" popup="true"/>
+ <reference id="Blaze.NewPackageAction"/>
+ <reference id="Blaze.NewRuleAction"/>
<separator/>
</group>
@@ -137,6 +177,8 @@
<projectService serviceImplementation="com.google.idea.blaze.base.buildmap.FileToBuildMap"/>
<projectService serviceInterface="com.google.idea.blaze.base.targetmaps.SourceToTargetMap"
serviceImplementation="com.google.idea.blaze.base.targetmaps.SourceToTargetMapImpl"/>
+ <projectService serviceInterface="com.google.idea.blaze.base.targetmaps.TransitiveDependencyMap"
+ serviceImplementation="com.google.idea.blaze.base.targetmaps.TransitiveDependencyMap"/>
<projectService serviceImplementation="com.google.idea.blaze.base.settings.BlazeImportSettingsManager"/>
<projectService serviceImplementation="com.google.idea.blaze.base.settings.BlazeImportSettingsManagerLegacy"/>
<applicationService serviceImplementation="com.google.idea.blaze.base.settings.BlazeUserSettings"/>
@@ -147,6 +189,8 @@
<applicationService serviceInterface="com.google.idea.blaze.base.prefetch.PrefetchService"
serviceImplementation="com.google.idea.blaze.base.prefetch.PrefetchServiceImpl"/>
<applicationService serviceImplementation="com.google.idea.blaze.base.wizard2.BlazeWizardUserSettingsStorage"/>
+ <applicationService serviceInterface="com.google.idea.blaze.base.wizard2.BlazeWizardOptionProvider"
+ serviceImplementation="com.google.idea.blaze.base.wizard2.BazelWizardOptionProvider"/>
<projectService serviceInterface="com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverProvider"
serviceImplementation="com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverProviderImpl"/>
<configurationType implementation="com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType"/>
@@ -159,6 +203,7 @@
<stepsBeforeRunProvider implementation="com.google.idea.blaze.base.run.BlazeBeforeRunTaskProvider"/>
<applicationService serviceInterface="com.google.idea.blaze.base.help.BlazeHelpHandler"
serviceImplementation="com.google.idea.blaze.base.help.BlazeHelpHandlerImpl"/>
+ <applicationService serviceImplementation="com.google.idea.blaze.base.actions.BlazeBuildService"/>
<additionalTextAttributes scheme="Default" file="base/resources/colorSchemes/BuildDefault.xml"/>
<typedHandler implementation="com.google.idea.blaze.base.lang.buildfile.completion.BuildCompletionAutoPopupHandler"/>
@@ -254,8 +299,6 @@
<extensionPoint qualifiedName="com.google.idea.blaze.PsiFileProvider" interface="com.google.idea.blaze.base.lang.buildfile.search.PsiFileProvider"/>
<extensionPoint qualifiedName="com.google.idea.blaze.VcsHandler"
interface="com.google.idea.blaze.base.vcs.BlazeVcsHandler"/>
- <extensionPoint qualifiedName="com.google.idea.blaze.BlazeWizardOptionProvider"
- interface="com.google.idea.blaze.base.wizard2.BlazeWizardOptionProvider"/>
<extensionPoint qualifiedName="com.google.idea.blaze.DefaultSdkProvider"
interface="com.google.idea.blaze.base.sync.sdk.DefaultSdkProvider"/>
<extensionPoint qualifiedName="com.google.idea.blaze.BuildFlagsProvider" interface="com.google.idea.blaze.base.command.BuildFlagsProvider"/>
@@ -269,6 +312,7 @@
<extensionPoint qualifiedName="com.google.idea.blaze.TestTargetHeuristic" interface="com.google.idea.blaze.base.run.TestTargetHeuristic"/>
<extensionPoint qualifiedName="com.google.idea.blaze.ProjectDataDirectoryValidator" interface="com.google.idea.blaze.base.wizard2.ProjectDataDirectoryValidator"/>
<extensionPoint qualifiedName="com.google.idea.blaze.AspectStrategyProvider" interface="com.google.idea.blaze.base.sync.aspects.strategy.AspectStrategyProvider"/>
+ <extensionPoint qualifiedName="com.google.idea.blaze.DistributedExecutorSupport" interface="com.google.idea.blaze.base.run.DistributedExecutorSupport"/>
</extensionPoints>
<extensions defaultExtensionNs="com.google.idea.blaze">
@@ -276,9 +320,7 @@
<SyncListener implementation="com.google.idea.blaze.base.sync.status.BlazeSyncStatusListener"/>
<SyncListener implementation="com.google.idea.blaze.base.run.testmap.TestTargetFilterImpl$ClearTestMap"/>
<SyncListener implementation="com.google.idea.blaze.base.targetmaps.SourceToTargetMapImpl$ClearSourceToTargetMap"/>
- <SyncListener implementation="com.google.idea.blaze.base.lang.buildfile.language.semantics.BuildLanguageSpecProviderImpl"/>
<SyncPlugin implementation="com.google.idea.blaze.base.lang.buildfile.sync.BuildLangSyncPlugin"/>
- <BlazeWizardOptionProvider implementation="com.google.idea.blaze.base.wizard2.BazelWizardOptionProvider"/>
<BuildFlagsProvider implementation="com.google.idea.blaze.base.command.BuildFlagsProviderImpl"/>
<VcsHandler implementation="com.google.idea.blaze.base.vcs.git.GitBlazeVcsHandler"/>
<VcsHandler implementation="com.google.idea.blaze.base.vcs.FallbackBlazeVcsHandler" order="last" id="fallback"/>
diff --git a/base/src/com/google/idea/blaze/base/actions/BlazeAction.java b/base/src/com/google/idea/blaze/base/actions/BlazeAction.java
deleted file mode 100644
index ed31396..0000000
--- a/base/src/com/google/idea/blaze/base/actions/BlazeAction.java
+++ /dev/null
@@ -1,59 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.base.actions;
-
-import com.google.idea.blaze.base.settings.Blaze;
-import com.intellij.openapi.actionSystem.AnAction;
-import com.intellij.openapi.actionSystem.AnActionEvent;
-import com.intellij.openapi.project.Project;
-import javax.swing.Icon;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-/** Base class action that hides for non-blaze projects. */
-public abstract class BlazeAction extends AnAction {
- protected BlazeAction() {}
-
- protected BlazeAction(Icon icon) {
- super(icon);
- }
-
- protected BlazeAction(@Nullable String text) {
- super(text);
- }
-
- protected BlazeAction(@Nullable String text, @Nullable String description, @Nullable Icon icon) {
- super(text, description, icon);
- }
-
- @Override
- public final void update(AnActionEvent e) {
- if (!isBlazeProject(e)) {
- e.getPresentation().setEnabledAndVisible(false);
- return;
- }
-
- e.getPresentation().setEnabledAndVisible(true);
- doUpdate(e);
- }
-
- protected void doUpdate(@NotNull AnActionEvent e) {}
-
- private static boolean isBlazeProject(@NotNull AnActionEvent e) {
- Project project = e.getProject();
- return project != null && Blaze.isBlazeProject(project);
- }
-}
diff --git a/base/src/com/google/idea/blaze/base/actions/BlazeBuildService.java b/base/src/com/google/idea/blaze/base/actions/BlazeBuildService.java
new file mode 100644
index 0000000..4da44f1
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/actions/BlazeBuildService.java
@@ -0,0 +1,141 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.actions;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.Lists;
+import com.google.idea.blaze.base.async.executor.BlazeExecutor;
+import com.google.idea.blaze.base.experiments.ExperimentScope;
+import com.google.idea.blaze.base.filecache.FileCaches;
+import com.google.idea.blaze.base.metrics.Action;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.model.primitives.TargetExpression;
+import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
+import com.google.idea.blaze.base.projectview.ProjectViewManager;
+import com.google.idea.blaze.base.projectview.ProjectViewSet;
+import com.google.idea.blaze.base.projectview.section.sections.TargetSection;
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.scope.ScopedTask;
+import com.google.idea.blaze.base.scope.scopes.BlazeConsoleScope;
+import com.google.idea.blaze.base.scope.scopes.IdeaLogScope;
+import com.google.idea.blaze.base.scope.scopes.IssuesScope;
+import com.google.idea.blaze.base.scope.scopes.LoggedTimingScope;
+import com.google.idea.blaze.base.scope.scopes.NotificationScope;
+import com.google.idea.blaze.base.scope.scopes.TimingScope;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.blaze.base.util.SaveUtil;
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.project.Project;
+import java.util.List;
+
+/** Utility to build various collections of targets. */
+public class BlazeBuildService {
+ public static BlazeBuildService getInstance() {
+ return ServiceManager.getService(BlazeBuildService.class);
+ }
+
+ public void buildFile(Project project, String fileName, ImmutableCollection<Label> targets) {
+ if (project == null || !Blaze.isBlazeProject(project) || fileName == null) {
+ return;
+ }
+ buildTargetExpressions(
+ project,
+ Lists.newArrayList(targets),
+ ProjectViewManager.getInstance(project).getProjectViewSet(),
+ new LoggedTimingScope(project, Action.MAKE_MODULE_TOTAL_TIME),
+ new NotificationScope(
+ project,
+ "Make",
+ "Make " + fileName,
+ "Make " + fileName + " completed successfully",
+ "Make " + fileName + " failed"));
+ }
+
+ public void buildProject(Project project) {
+ if (project == null || !Blaze.isBlazeProject(project)) {
+ return;
+ }
+ ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
+ if (projectViewSet == null) {
+ return;
+ }
+ buildTargetExpressions(
+ project,
+ projectViewSet.listItems(TargetSection.KEY),
+ projectViewSet,
+ new LoggedTimingScope(project, Action.MAKE_PROJECT_TOTAL_TIME),
+ new NotificationScope(
+ project,
+ "Make",
+ "Make project",
+ "Make project completed successfully",
+ "Make project failed"));
+ }
+
+ @VisibleForTesting
+ void buildTargetExpressions(
+ Project project,
+ List<TargetExpression> targets,
+ ProjectViewSet projectViewSet,
+ LoggedTimingScope loggedTimingScope,
+ NotificationScope notificationScope) {
+ if (targets.isEmpty() || projectViewSet == null) {
+ return;
+ }
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+ if (blazeProjectData == null) {
+ return;
+ }
+ BlazeExecutor.submitTask(
+ project,
+ new ScopedTask() {
+ @Override
+ public void execute(BlazeContext context) {
+ context
+ .push(new ExperimentScope())
+ .push(new BlazeConsoleScope.Builder(project).build())
+ .push(new IssuesScope(project))
+ .push(new IdeaLogScope())
+ .push(new TimingScope("Make"))
+ .push(loggedTimingScope)
+ .push(notificationScope);
+
+ WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
+ BlazeIdeInterface blazeIdeInterface = BlazeIdeInterface.getInstance();
+
+ SaveUtil.saveAllFiles();
+ BlazeIdeInterface.BuildResult buildResult =
+ blazeIdeInterface.compileIdeArtifacts(
+ project,
+ context,
+ workspaceRoot,
+ projectViewSet,
+ blazeProjectData.blazeVersionData,
+ targets);
+ FileCaches.refresh(project);
+
+ if (buildResult != BlazeIdeInterface.BuildResult.SUCCESS) {
+ context.setHasError();
+ }
+ }
+ });
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/actions/BlazeCompileFileAction.java b/base/src/com/google/idea/blaze/base/actions/BlazeCompileFileAction.java
index 00ad470..130de1b 100644
--- a/base/src/com/google/idea/blaze/base/actions/BlazeCompileFileAction.java
+++ b/base/src/com/google/idea/blaze/base/actions/BlazeCompileFileAction.java
@@ -17,65 +17,29 @@
import com.google.common.collect.ImmutableCollection;
import com.google.common.collect.ImmutableList;
-import com.google.common.collect.Lists;
-import com.google.idea.blaze.base.async.executor.BlazeExecutor;
-import com.google.idea.blaze.base.experiments.ExperimentScope;
-import com.google.idea.blaze.base.filecache.FileCaches;
-import com.google.idea.blaze.base.metrics.Action;
-import com.google.idea.blaze.base.model.BlazeProjectData;
import com.google.idea.blaze.base.model.primitives.Label;
-import com.google.idea.blaze.base.model.primitives.TargetExpression;
-import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
-import com.google.idea.blaze.base.projectview.ProjectViewManager;
-import com.google.idea.blaze.base.projectview.ProjectViewSet;
-import com.google.idea.blaze.base.scope.BlazeContext;
-import com.google.idea.blaze.base.scope.ScopedTask;
-import com.google.idea.blaze.base.scope.scopes.BlazeConsoleScope;
-import com.google.idea.blaze.base.scope.scopes.IdeaLogScope;
-import com.google.idea.blaze.base.scope.scopes.IssuesScope;
-import com.google.idea.blaze.base.scope.scopes.LoggedTimingScope;
-import com.google.idea.blaze.base.scope.scopes.NotificationScope;
-import com.google.idea.blaze.base.scope.scopes.TimingScope;
-import com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface;
-import com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface.BuildResult;
-import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
import com.google.idea.blaze.base.targetmaps.SourceToTargetMap;
-import com.google.idea.blaze.base.util.SaveUtil;
+import com.google.idea.common.actionhelper.ActionPresentationHelper;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.CommonDataKeys;
-import com.intellij.openapi.actionSystem.Presentation;
-import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import java.io.File;
-import java.util.List;
-import org.jetbrains.annotations.NotNull;
-class BlazeCompileFileAction extends BlazeAction {
- private static final Logger LOG = Logger.getInstance(BlazeCompileFileAction.class);
+class BlazeCompileFileAction extends BlazeProjectAction {
- public BlazeCompileFileAction() {
- super("Compile file");
+ @Override
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
+ ActionPresentationHelper.of(e)
+ .disableIf(getTargets(e).isEmpty())
+ .setTextWithSubject("Compile File", "Compile %s", e.getData(CommonDataKeys.VIRTUAL_FILE))
+ .disableWithoutSubject()
+ .commit();
}
@Override
- protected void doUpdate(@NotNull AnActionEvent e) {
- // IntelliJ uses different logic for 1 vs many module selection. When many modules are selected
- // modules with more than 1 content root are ignored
- // (ProjectViewImpl#moduleBySingleContentRoot).
- if (getTargets(e).isEmpty()) {
- Presentation presentation = e.getPresentation();
- presentation.setEnabled(false);
- }
- }
-
- @Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- if (project != null) {
- ImmutableCollection<Label> targets = getTargets(e);
- buildSourceFile(project, targets);
- }
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
+ BlazeBuildService.getInstance().buildFile(project, getFileName(e), getTargets(e));
}
private ImmutableCollection<Label> getTargets(AnActionEvent e) {
@@ -88,53 +52,8 @@
return ImmutableList.of();
}
- private static void buildSourceFile(
- @NotNull Project project, @NotNull ImmutableCollection<Label> targets) {
- BlazeProjectData blazeProjectData =
- BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
- if (blazeProjectData == null || targets.isEmpty()) {
- return;
- }
- final ProjectViewSet projectViewSet =
- ProjectViewManager.getInstance(project).getProjectViewSet();
- if (projectViewSet == null) {
- return;
- }
- BlazeExecutor.submitTask(
- project,
- new ScopedTask() {
- @Override
- public void execute(@NotNull BlazeContext context) {
- context
- .push(new ExperimentScope())
- .push(new BlazeConsoleScope.Builder(project).build())
- .push(new IssuesScope(project))
- .push(new IdeaLogScope())
- .push(new TimingScope("Make"))
- .push(new LoggedTimingScope(project, Action.MAKE_MODULE_TOTAL_TIME))
- .push(
- new NotificationScope(
- project,
- "Make",
- "Make module",
- "Make module completed successfully",
- "Make module failed"));
-
- WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
-
- BlazeIdeInterface blazeIdeInterface = BlazeIdeInterface.getInstance();
- List<TargetExpression> targetExpressions = Lists.newArrayList(targets);
-
- SaveUtil.saveAllFiles();
- BuildResult buildResult =
- blazeIdeInterface.resolveIdeArtifacts(
- project, context, workspaceRoot, projectViewSet, targetExpressions);
- FileCaches.refresh(project);
-
- if (buildResult != BuildResult.SUCCESS) {
- context.setHasError();
- }
- }
- });
+ private static String getFileName(AnActionEvent e) {
+ VirtualFile virtualFile = e.getData(CommonDataKeys.VIRTUAL_FILE);
+ return virtualFile == null ? null : virtualFile.getName();
}
}
diff --git a/base/src/com/google/idea/blaze/base/actions/BlazeMakeProjectAction.java b/base/src/com/google/idea/blaze/base/actions/BlazeMakeProjectAction.java
index 64964c5..a124759 100644
--- a/base/src/com/google/idea/blaze/base/actions/BlazeMakeProjectAction.java
+++ b/base/src/com/google/idea/blaze/base/actions/BlazeMakeProjectAction.java
@@ -15,102 +15,13 @@
*/
package com.google.idea.blaze.base.actions;
-import com.google.common.collect.Lists;
-import com.google.idea.blaze.base.async.executor.BlazeExecutor;
-import com.google.idea.blaze.base.experiments.ExperimentScope;
-import com.google.idea.blaze.base.filecache.FileCaches;
-import com.google.idea.blaze.base.metrics.Action;
-import com.google.idea.blaze.base.model.BlazeProjectData;
-import com.google.idea.blaze.base.model.primitives.TargetExpression;
-import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
-import com.google.idea.blaze.base.projectview.ProjectViewManager;
-import com.google.idea.blaze.base.projectview.ProjectViewSet;
-import com.google.idea.blaze.base.projectview.section.sections.TargetSection;
-import com.google.idea.blaze.base.scope.BlazeContext;
-import com.google.idea.blaze.base.scope.ScopedTask;
-import com.google.idea.blaze.base.scope.scopes.BlazeConsoleScope;
-import com.google.idea.blaze.base.scope.scopes.IdeaLogScope;
-import com.google.idea.blaze.base.scope.scopes.IssuesScope;
-import com.google.idea.blaze.base.scope.scopes.LoggedTimingScope;
-import com.google.idea.blaze.base.scope.scopes.NotificationScope;
-import com.google.idea.blaze.base.scope.scopes.TimingScope;
-import com.google.idea.blaze.base.settings.Blaze;
-import com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface;
-import com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface.BuildResult;
-import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
-import com.google.idea.blaze.base.util.SaveUtil;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.project.Project;
-import java.util.List;
-import org.jetbrains.annotations.NotNull;
-class BlazeMakeProjectAction extends BlazeAction {
-
- public BlazeMakeProjectAction() {
- super("Make Project");
- }
+class BlazeMakeProjectAction extends BlazeProjectAction {
@Override
- public final void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- if (project != null && Blaze.isBlazeProject(project)) {
- buildBlazeProject(project);
- }
- }
-
- protected void buildBlazeProject(@NotNull final Project project) {
-
- BlazeExecutor.submitTask(
- project,
- new ScopedTask() {
- @Override
- public void execute(@NotNull BlazeContext context) {
- context
- .push(new ExperimentScope())
- .push(new BlazeConsoleScope.Builder(project).build())
- .push(new IssuesScope(project))
- .push(new IdeaLogScope())
- .push(new TimingScope("Make"))
- .push(new LoggedTimingScope(project, Action.MAKE_PROJECT_TOTAL_TIME))
- .push(
- new NotificationScope(
- project,
- "Make",
- "Make project",
- "Make project completed successfully",
- "Make project failed"));
-
- BlazeProjectData blazeProjectData =
- BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
- if (blazeProjectData == null) {
- return;
- }
- SaveUtil.saveAllFiles();
-
- ProjectViewSet projectViewSet =
- ProjectViewManager.getInstance(project)
- .reloadProjectView(context, blazeProjectData.workspacePathResolver);
- if (projectViewSet == null) {
- return;
- }
-
- WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
-
- List<TargetExpression> targets = Lists.newArrayList();
- targets.addAll(projectViewSet.listItems(TargetSection.KEY));
-
- BlazeIdeInterface blazeIdeInterface = BlazeIdeInterface.getInstance();
-
- BuildResult buildResult =
- blazeIdeInterface.resolveIdeArtifacts(
- project, context, workspaceRoot, projectViewSet, targets);
- FileCaches.refresh(project);
-
- if (buildResult != BuildResult.SUCCESS) {
- context.setHasError();
- ;
- }
- }
- });
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
+ BlazeBuildService.getInstance().buildProject(project);
}
}
diff --git a/base/src/com/google/idea/blaze/base/actions/BlazeProjectAction.java b/base/src/com/google/idea/blaze/base/actions/BlazeProjectAction.java
new file mode 100644
index 0000000..fdf81be
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/actions/BlazeProjectAction.java
@@ -0,0 +1,86 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.actions;
+
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
+import com.intellij.openapi.actionSystem.AnAction;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.project.Project;
+import javax.annotation.Nullable;
+import javax.swing.Icon;
+
+/** Base class action that hides for non-blaze projects. */
+public abstract class BlazeProjectAction extends AnAction {
+ protected BlazeProjectAction() {}
+
+ protected BlazeProjectAction(Icon icon) {
+ super(icon);
+ }
+
+ protected BlazeProjectAction(@Nullable String text) {
+ super(text);
+ }
+
+ protected BlazeProjectAction(
+ @Nullable String text, @Nullable String description, @Nullable Icon icon) {
+ super(text, description, icon);
+ }
+
+ @Override
+ public final void update(AnActionEvent e) {
+ Project project = e.getProject();
+ if (project == null || !Blaze.isBlazeProject(project)) {
+ e.getPresentation().setEnabledAndVisible(false);
+ return;
+ }
+
+ e.getPresentation().setEnabledAndVisible(true);
+
+ if (!compatibleBuildSystem(project)) {
+ e.getPresentation().setEnabled(false);
+ return;
+ }
+
+ updateForBlazeProject(project, e);
+ }
+
+ @Override
+ public final void actionPerformed(AnActionEvent anActionEvent) {
+ Project project = anActionEvent.getProject();
+ if (project == null) {
+ return;
+ }
+ actionPerformedInBlazeProject(project, anActionEvent);
+ }
+
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {}
+
+ protected abstract void actionPerformedInBlazeProject(Project project, AnActionEvent e);
+
+ private boolean compatibleBuildSystem(Project project) {
+ BuildSystem requiredBuildSystem = requiredBuildSystem();
+ if (requiredBuildSystem == null) {
+ return true;
+ }
+ return Blaze.getBuildSystem(project) == requiredBuildSystem;
+ }
+
+ @Nullable
+ protected BuildSystem requiredBuildSystem() {
+ return null;
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/actions/BlazeToggleAction.java b/base/src/com/google/idea/blaze/base/actions/BlazeProjectToggleAction.java
similarity index 73%
rename from base/src/com/google/idea/blaze/base/actions/BlazeToggleAction.java
rename to base/src/com/google/idea/blaze/base/actions/BlazeProjectToggleAction.java
index 0413761..270f067 100644
--- a/base/src/com/google/idea/blaze/base/actions/BlazeToggleAction.java
+++ b/base/src/com/google/idea/blaze/base/actions/BlazeProjectToggleAction.java
@@ -19,39 +19,34 @@
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.ToggleAction;
import com.intellij.openapi.project.Project;
+import javax.annotation.Nullable;
import javax.swing.Icon;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
/** Base class toggle action that hides for non-blaze projects. */
-public abstract class BlazeToggleAction extends ToggleAction {
- protected BlazeToggleAction() {}
+public abstract class BlazeProjectToggleAction extends ToggleAction {
+ protected BlazeProjectToggleAction() {}
- protected BlazeToggleAction(@Nullable String text) {
+ protected BlazeProjectToggleAction(@Nullable String text) {
super(text);
}
- protected BlazeToggleAction(
+ protected BlazeProjectToggleAction(
@Nullable String text, @Nullable String description, @Nullable Icon icon) {
super(text, description, icon);
}
@Override
public final void update(AnActionEvent e) {
- if (!isBlazeProject(e)) {
+ Project project = e.getProject();
+ if (project == null || !Blaze.isBlazeProject(project)) {
e.getPresentation().setEnabledAndVisible(false);
return;
}
e.getPresentation().setEnabledAndVisible(true);
super.update(e);
- doUpdate(e);
+ updateForBlazeProject(project, e);
}
- protected void doUpdate(@NotNull AnActionEvent e) {}
-
- private static boolean isBlazeProject(@NotNull AnActionEvent e) {
- Project project = e.getProject();
- return project != null && Blaze.isBlazeProject(project);
- }
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {}
}
diff --git a/base/src/com/google/idea/blaze/base/async/AsyncUtil.java b/base/src/com/google/idea/blaze/base/async/AsyncUtil.java
deleted file mode 100644
index 153f995..0000000
--- a/base/src/com/google/idea/blaze/base/async/AsyncUtil.java
+++ /dev/null
@@ -1,58 +0,0 @@
-/*
- * Copyright 2016 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.idea.blaze.base.async;
-
-import com.intellij.openapi.application.ApplicationManager;
-import com.intellij.util.ui.UIUtil;
-import org.jetbrains.annotations.NotNull;
-
-/** Async utilities. */
-public class AsyncUtil {
- public static void executeProjectChangeAction(@NotNull final Runnable task) throws Throwable {
- final ValueHolder<Throwable> error = new ValueHolder<Throwable>();
-
- executeOnEdt(
- new Runnable() {
- @Override
- public void run() {
- ApplicationManager.getApplication()
- .runWriteAction(
- new Runnable() {
- @Override
- public void run() {
- try {
- task.run();
- } catch (Throwable t) {
- error.value = t;
- }
- }
- });
- }
- });
-
- if (error.value != null) {
- throw error.value;
- }
- }
-
- private static void executeOnEdt(@NotNull Runnable task) {
- if (ApplicationManager.getApplication().isDispatchThread()) {
- task.run();
- } else {
- UIUtil.invokeAndWaitIfNeeded(task);
- }
- }
-}
diff --git a/base/src/com/google/idea/blaze/base/bazel/BazelBuildSystemProvider.java b/base/src/com/google/idea/blaze/base/bazel/BazelBuildSystemProvider.java
index d207ff2..b3d4598 100644
--- a/base/src/com/google/idea/blaze/base/bazel/BazelBuildSystemProvider.java
+++ b/base/src/com/google/idea/blaze/base/bazel/BazelBuildSystemProvider.java
@@ -16,8 +16,10 @@
package com.google.idea.blaze.base.bazel;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
import com.google.idea.blaze.base.io.FileAttributeProvider;
import com.google.idea.blaze.base.lang.buildfile.language.semantics.RuleDefinition;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.intellij.openapi.fileTypes.ExactFileNameMatcher;
@@ -27,6 +29,7 @@
/** Provides the bazel build system name string. */
public class BazelBuildSystemProvider implements BuildSystemProvider {
+
@Override
public BuildSystem buildSystem() {
return BuildSystem.Bazel;
@@ -72,4 +75,16 @@
public FileNameMatcher buildFileMatcher() {
return new ExactFileNameMatcher("BUILD");
}
+
+ @Override
+ public void populateBlazeVersionData(
+ BuildSystem buildSystem,
+ WorkspaceRoot workspaceRoot,
+ ImmutableMap<String, String> blazeInfo,
+ BlazeVersionData.Builder builder) {
+ if (buildSystem != BuildSystem.Bazel) {
+ return;
+ }
+ builder.setBazelVersion(BazelVersion.parseVersion(blazeInfo));
+ }
}
diff --git a/base/src/com/google/idea/blaze/base/bazel/BazelVersion.java b/base/src/com/google/idea/blaze/base/bazel/BazelVersion.java
new file mode 100644
index 0000000..44582cb
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/bazel/BazelVersion.java
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.bazel;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.base.Objects;
+import com.google.common.collect.ComparisonChain;
+import com.google.idea.blaze.base.command.info.BlazeInfo;
+import com.intellij.openapi.util.text.StringUtil;
+import java.io.Serializable;
+import java.util.Map;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+import javax.annotation.Nullable;
+
+/** Bazel version */
+public class BazelVersion implements Serializable {
+ private static final long serialVersionUID = 1L;
+
+ public static final BazelVersion UNKNOWN = new BazelVersion(0, 0, 0);
+ private static final Pattern PATTERN = Pattern.compile("([[0-9]\\.]+)");
+
+ public final int major;
+ public final int minor;
+ public final int bugfix;
+
+ BazelVersion(int major, int minor, int bugfix) {
+ this.bugfix = bugfix;
+ this.minor = minor;
+ this.major = major;
+ }
+
+ @VisibleForTesting
+ static BazelVersion parseVersion(@Nullable String string) {
+ if (string == null) {
+ return UNKNOWN;
+ }
+ Matcher matcher = PATTERN.matcher(string);
+ if (!matcher.find()) {
+ return UNKNOWN;
+ }
+ try {
+ BazelVersion version = parseVersion(matcher.group(1).split("\\."));
+ if (version == null) {
+ return UNKNOWN;
+ }
+ return version;
+ } catch (Exception e) {
+ return UNKNOWN;
+ }
+ }
+
+ @Nullable
+ private static BazelVersion parseVersion(String[] numbers) {
+ if (numbers.length < 1) {
+ return null;
+ }
+ int major = StringUtil.parseInt(numbers[0], -1);
+ if (major < 0) {
+ return null;
+ }
+ int minor = numbers.length > 1 ? StringUtil.parseInt(numbers[1], 0) : 0;
+ int bugfix = numbers.length > 2 ? StringUtil.parseInt(numbers[2], 0) : 0;
+ return new BazelVersion(major, minor, bugfix);
+ }
+
+ public static BazelVersion parseVersion(Map<String, String> blazeInfo) {
+ return parseVersion(blazeInfo.get(BlazeInfo.RELEASE));
+ }
+
+ @Override
+ public boolean equals(Object o) {
+ if (this == o) {
+ return true;
+ }
+ if (o == null || getClass() != o.getClass()) {
+ return false;
+ }
+ BazelVersion that = (BazelVersion) o;
+ return major == that.major && minor == that.minor && bugfix == that.bugfix;
+ }
+
+ @Override
+ public int hashCode() {
+ return Objects.hashCode(major, minor, bugfix);
+ }
+
+ public boolean isAtLeast(int major, int minor, int bugfix) {
+ return ComparisonChain.start()
+ .compare(this.major, major)
+ .compare(this.minor, minor)
+ .compare(this.bugfix, bugfix)
+ .result()
+ >= 0;
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/bazel/BuildSystemProvider.java b/base/src/com/google/idea/blaze/base/bazel/BuildSystemProvider.java
index 4b47716..6ce5aca 100644
--- a/base/src/com/google/idea/blaze/base/bazel/BuildSystemProvider.java
+++ b/base/src/com/google/idea/blaze/base/bazel/BuildSystemProvider.java
@@ -16,7 +16,9 @@
package com.google.idea.blaze.base.bazel;
import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
import com.google.idea.blaze.base.lang.buildfile.language.semantics.RuleDefinition;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.intellij.openapi.components.ServiceManager;
@@ -105,4 +107,11 @@
}
FileNameMatcher buildFileMatcher();
+
+ /** Populates the passed builder with version data. */
+ void populateBlazeVersionData(
+ BuildSystem buildSystem,
+ WorkspaceRoot workspaceRoot,
+ ImmutableMap<String, String> blazeInfo,
+ BlazeVersionData.Builder builder);
}
diff --git a/base/src/com/google/idea/blaze/base/buildmap/OpenCorrespondingBuildFile.java b/base/src/com/google/idea/blaze/base/buildmap/OpenCorrespondingBuildFile.java
index 2754da2..592b7b4 100644
--- a/base/src/com/google/idea/blaze/base/buildmap/OpenCorrespondingBuildFile.java
+++ b/base/src/com/google/idea/blaze/base/buildmap/OpenCorrespondingBuildFile.java
@@ -16,7 +16,7 @@
package com.google.idea.blaze.base.buildmap;
import com.google.common.collect.Iterables;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.metrics.Action;
import com.google.idea.blaze.base.metrics.LoggingService;
import com.intellij.ide.actions.OpenFileAction;
@@ -29,16 +29,12 @@
import com.intellij.openapi.vfs.VirtualFile;
import java.io.File;
import java.util.Collection;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import javax.annotation.Nullable;
-class OpenCorrespondingBuildFile extends BlazeAction {
+class OpenCorrespondingBuildFile extends BlazeProjectAction {
+
@Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- if (project == null) {
- return;
- }
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
VirtualFile virtualFile = e.getData(CommonDataKeys.VIRTUAL_FILE);
File file = getBuildFile(project, virtualFile);
if (file == null) {
@@ -49,10 +45,7 @@
}
@Nullable
- private File getBuildFile(@Nullable Project project, @Nullable VirtualFile virtualFile) {
- if (project == null) {
- return null;
- }
+ private File getBuildFile(Project project, @Nullable VirtualFile virtualFile) {
if (virtualFile == null) {
return null;
}
@@ -62,12 +55,11 @@
}
@Override
- protected void doUpdate(@NotNull AnActionEvent e) {
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
Presentation presentation = e.getPresentation();
DataContext dataContext = e.getDataContext();
VirtualFile virtualFile = CommonDataKeys.VIRTUAL_FILE.getData(dataContext);
- Project project = CommonDataKeys.PROJECT.getData(dataContext);
- boolean visible = (project != null && virtualFile != null);
+ boolean visible = virtualFile != null;
boolean enabled = getBuildFile(project, virtualFile) != null;
presentation.setVisible(visible || ActionPlaces.isMainMenuOrActionSearch(e.getPlace()));
presentation.setEnabled(enabled);
diff --git a/base/src/com/google/idea/blaze/base/command/BlazeFlags.java b/base/src/com/google/idea/blaze/base/command/BlazeFlags.java
index 2338f24..1f24f62 100644
--- a/base/src/com/google/idea/blaze/base/command/BlazeFlags.java
+++ b/base/src/com/google/idea/blaze/base/command/BlazeFlags.java
@@ -41,13 +41,6 @@
public static final String TEST_OUTPUT_STREAMED = "--test_output=streamed";
// Filters the unit tests that are run (used with regexp for Java/Robolectric tests).
public static final String TEST_FILTER = "--test_filter";
- // Skips checking for output file modifications (reduced statting -> faster).
- public static final String NO_CHECK_OUTPUTS = "--noexperimental_check_output_files";
- // Ignores implicit dependencies (e.g. java_library rules depending implicitly on
- // "//transconsole/tools:aggregate_messages" in order to support translations).
- public static final String NO_IMPLICIT_DEPS = "--noimplicit_deps";
- // Ignores host dependencies.
- public static final String NO_HOST_DEPS = "--nohost_deps";
// When used with mobile-install, deploys the an app incrementally.
public static final String INCREMENTAL = "--incremental";
// When used with mobile-install, deploys the an app incrementally
diff --git a/base/src/com/google/idea/blaze/base/command/BuildFlagsProviderImpl.java b/base/src/com/google/idea/blaze/base/command/BuildFlagsProviderImpl.java
index 290f001..2e40662 100644
--- a/base/src/com/google/idea/blaze/base/command/BuildFlagsProviderImpl.java
+++ b/base/src/com/google/idea/blaze/base/command/BuildFlagsProviderImpl.java
@@ -15,7 +15,6 @@
*/
package com.google.idea.blaze.base.command;
-import static com.google.idea.blaze.base.command.BlazeFlags.NO_CHECK_OUTPUTS;
import static com.google.idea.blaze.base.command.BlazeFlags.VERSION_WINDOW_FOR_DIRTY_NODE_GC;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
@@ -28,8 +27,6 @@
private static final BoolExperiment experimentUseVersionWindowForDirtyNodeGc =
new BoolExperiment("ide_build_info.use_version_window_for_dirty_node_gc", false);
- private static final BoolExperiment experimentNoExperimentalCheckOutputFiles =
- new BoolExperiment("build.noexperimental_check_output_files", false);
@Override
public void addBuildFlags(
@@ -37,9 +34,6 @@
if (experimentUseVersionWindowForDirtyNodeGc.getValue()) {
flags.add(VERSION_WINDOW_FOR_DIRTY_NODE_GC);
}
- if (experimentNoExperimentalCheckOutputFiles.getValue()) {
- flags.add(NO_CHECK_OUTPUTS);
- }
flags.add("--curses=no");
flags.add("--color=no");
}
diff --git a/base/src/com/google/idea/blaze/base/command/info/BlazeInfo.java b/base/src/com/google/idea/blaze/base/command/info/BlazeInfo.java
index 5346e8c..6099fc2 100644
--- a/base/src/com/google/idea/blaze/base/command/info/BlazeInfo.java
+++ b/base/src/com/google/idea/blaze/base/command/info/BlazeInfo.java
@@ -31,6 +31,7 @@
public static final String BUILD_LANGUAGE = "build-language";
public static final String OUTPUT_BASE_KEY = "output_base";
public static final String MASTER_LOG = "master-log";
+ public static final String RELEASE = "release";
public static String blazeBinKey(BuildSystem buildSystem) {
switch (buildSystem) {
diff --git a/base/src/com/google/idea/blaze/base/ide/NewBlazePackageAction.java b/base/src/com/google/idea/blaze/base/ide/NewBlazePackageAction.java
index 3780bf1..2d0f519 100644
--- a/base/src/com/google/idea/blaze/base/ide/NewBlazePackageAction.java
+++ b/base/src/com/google/idea/blaze/base/ide/NewBlazePackageAction.java
@@ -18,7 +18,7 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.buildmodifier.BuildFileModifier;
import com.google.idea.blaze.base.buildmodifier.FileSystemModifier;
import com.google.idea.blaze.base.metrics.Action;
@@ -41,7 +41,6 @@
import com.intellij.ide.IdeView;
import com.intellij.ide.util.DirectoryChooserUtil;
import com.intellij.openapi.actionSystem.AnActionEvent;
-import com.intellij.openapi.actionSystem.CommonDataKeys;
import com.intellij.openapi.actionSystem.LangDataKeys;
import com.intellij.openapi.actionSystem.Presentation;
import com.intellij.openapi.diagnostic.Logger;
@@ -60,7 +59,7 @@
import javax.annotation.Nullable;
import org.jetbrains.annotations.NotNull;
-class NewBlazePackageAction extends BlazeAction implements DumbAware {
+class NewBlazePackageAction extends BlazeProjectAction implements DumbAware {
private static final Logger LOG = Logger.getInstance(NewBlazePackageAction.class);
private static final String BUILD_FILE_NAME = "BUILD";
@@ -70,9 +69,8 @@
}
@Override
- public void actionPerformed(AnActionEvent event) {
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent event) {
final IdeView view = event.getData(LangDataKeys.IDE_VIEW);
- final Project project = event.getData(CommonDataKeys.PROJECT);
Scope.root(
new ScopedOperation() {
@Override
@@ -160,10 +158,10 @@
}
@Override
- protected void doUpdate(@NotNull AnActionEvent event) {
+ protected void updateForBlazeProject(Project project, @NotNull AnActionEvent event) {
Presentation presentation = event.getPresentation();
if (isEnabled(event)) {
- String text = String.format("New %s Package", Blaze.buildSystemName(event.getProject()));
+ String text = String.format("New %s Package", Blaze.buildSystemName(project));
presentation.setEnabledAndVisible(true);
presentation.setText(text);
presentation.setDescription(text);
diff --git a/base/src/com/google/idea/blaze/base/ide/NewBlazeRuleAction.java b/base/src/com/google/idea/blaze/base/ide/NewBlazeRuleAction.java
index d67dccf..422dada 100644
--- a/base/src/com/google/idea/blaze/base/ide/NewBlazeRuleAction.java
+++ b/base/src/com/google/idea/blaze/base/ide/NewBlazeRuleAction.java
@@ -16,7 +16,7 @@
package com.google.idea.blaze.base.ide;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.experiments.ExperimentScope;
import com.google.idea.blaze.base.metrics.Action;
import com.google.idea.blaze.base.scope.Scope;
@@ -34,20 +34,15 @@
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import javax.annotation.Nullable;
-import org.jetbrains.annotations.NotNull;
-class NewBlazeRuleAction extends BlazeAction implements DumbAware {
+class NewBlazeRuleAction extends BlazeProjectAction implements DumbAware {
public NewBlazeRuleAction() {
super();
}
@Override
- public void actionPerformed(AnActionEvent event) {
- final Project project = event.getData(CommonDataKeys.PROJECT);
- if (project == null) {
- return;
- }
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent event) {
final VirtualFile virtualFile = event.getData(CommonDataKeys.VIRTUAL_FILE);
if (virtualFile == null) {
return;
@@ -68,15 +63,12 @@
}
@Override
- protected void doUpdate(@NotNull AnActionEvent event) {
+ protected void updateForBlazeProject(Project project, AnActionEvent event) {
Presentation presentation = event.getPresentation();
DataContext dataContext = event.getDataContext();
VirtualFile file = CommonDataKeys.VIRTUAL_FILE.getData(dataContext);
- Project project = CommonDataKeys.PROJECT.getData(dataContext);
boolean enabled =
- (project != null
- && file != null
- && Blaze.getBuildSystemProvider(project).isBuildFile(file.getName()));
+ file != null && Blaze.getBuildSystemProvider(project).isBuildFile(file.getName());
presentation.setVisible(enabled || ActionPlaces.isMainMenuOrActionSearch(event.getPlace()));
presentation.setEnabled(enabled);
presentation.setText(getText(project));
diff --git a/base/src/com/google/idea/blaze/base/ideinfo/TargetKey.java b/base/src/com/google/idea/blaze/base/ideinfo/TargetKey.java
index 0a347c6..d1e99a1 100644
--- a/base/src/com/google/idea/blaze/base/ideinfo/TargetKey.java
+++ b/base/src/com/google/idea/blaze/base/ideinfo/TargetKey.java
@@ -15,36 +15,42 @@
*/
package com.google.idea.blaze.base.ideinfo;
+import com.google.common.base.Joiner;
import com.google.common.base.Objects;
import com.google.common.collect.ComparisonChain;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Ordering;
import com.google.idea.blaze.base.model.primitives.Label;
import java.io.Serializable;
-import javax.annotation.Nullable;
+import java.util.List;
/** A key that uniquely idenfifies a target in the target map */
public class TargetKey implements Serializable, Comparable<TargetKey> {
- private static final long serialVersionUID = 2L;
+ private static final long serialVersionUID = 3L;
public final Label label;
- @Nullable private final String aspectId;
+ private final ImmutableList<String> aspectIds;
- private TargetKey(Label label, @Nullable String aspectId) {
+ private TargetKey(Label label, ImmutableList<String> aspectIds) {
this.label = label;
- this.aspectId = aspectId;
+ this.aspectIds = aspectIds;
}
/** Returns a key identifying a plain target */
public static TargetKey forPlainTarget(Label label) {
- return new TargetKey(label, null);
+ return new TargetKey(label, ImmutableList.of());
}
/** Returns a key identifying a general target */
- public static TargetKey forGeneralTarget(Label label, @Nullable String aspectId) {
- return new TargetKey(label, aspectId);
+ public static TargetKey forGeneralTarget(Label label, List<String> aspectIds) {
+ if (aspectIds.isEmpty()) {
+ return forPlainTarget(label);
+ }
+ return new TargetKey(label, ImmutableList.copyOf(aspectIds));
}
public boolean isPlainTarget() {
- return aspectId == null;
+ return aspectIds.isEmpty();
}
@Override
@@ -56,24 +62,27 @@
return false;
}
TargetKey key = (TargetKey) o;
- return Objects.equal(label, key.label) && Objects.equal(aspectId, key.aspectId);
+ return Objects.equal(label, key.label) && Objects.equal(aspectIds, key.aspectIds);
}
@Override
public int hashCode() {
- return Objects.hashCode(label, aspectId);
+ return Objects.hashCode(label, aspectIds);
}
@Override
public String toString() {
- if (aspectId == null) {
+ if (aspectIds.isEmpty()) {
return label.toString();
}
- return label.toString() + "#" + aspectId;
+ return label.toString() + "#" + Joiner.on('#').join(aspectIds);
}
@Override
public int compareTo(TargetKey o) {
- return ComparisonChain.start().compare(label, o.label).compare(aspectId, o.aspectId).result();
+ return ComparisonChain.start()
+ .compare(label, o.label)
+ .compare(aspectIds, o.aspectIds, Ordering.natural().lexicographical())
+ .result();
}
}
diff --git a/base/src/com/google/idea/blaze/base/lang/buildfile/language/semantics/BuildLanguageSpecProviderImpl.java b/base/src/com/google/idea/blaze/base/lang/buildfile/language/semantics/BuildLanguageSpecProviderImpl.java
index c57a138..f443957 100644
--- a/base/src/com/google/idea/blaze/base/lang/buildfile/language/semantics/BuildLanguageSpecProviderImpl.java
+++ b/base/src/com/google/idea/blaze/base/lang/buildfile/language/semantics/BuildLanguageSpecProviderImpl.java
@@ -15,41 +15,25 @@
*/
package com.google.idea.blaze.base.lang.buildfile.language.semantics;
-import com.google.common.collect.Maps;
import com.google.idea.blaze.base.lang.buildfile.sync.LanguageSpecResult;
import com.google.idea.blaze.base.model.BlazeProjectData;
-import com.google.idea.blaze.base.projectview.ProjectViewSet;
-import com.google.idea.blaze.base.scope.BlazeContext;
-import com.google.idea.blaze.base.settings.BlazeImportSettings;
-import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
-import com.google.idea.blaze.base.sync.SyncListener;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
import com.intellij.openapi.project.Project;
-import java.util.Map;
/** Calls 'blaze info build-language', to retrieve the language spec. */
-public class BuildLanguageSpecProviderImpl extends SyncListener.Adapter
- implements BuildLanguageSpecProvider {
-
- private static final Map<Project, LanguageSpecResult> calculatedSpecs = Maps.newHashMap();
+public class BuildLanguageSpecProviderImpl implements BuildLanguageSpecProvider {
@Override
public BuildLanguageSpec getLanguageSpec(Project project) {
- LanguageSpecResult result = calculatedSpecs.get(project);
- return result != null ? result.spec : null;
- }
-
- @Override
- public void onSyncComplete(
- Project project,
- BlazeContext context,
- BlazeImportSettings importSettings,
- ProjectViewSet projectViewSet,
- BlazeProjectData blazeProjectData,
- SyncMode syncMode,
- SyncResult syncResult) {
- LanguageSpecResult spec = blazeProjectData.syncState.get(LanguageSpecResult.class);
- if (spec != null) {
- calculatedSpecs.put(project, spec);
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+ if (blazeProjectData == null) {
+ return null;
}
+ LanguageSpecResult spec = blazeProjectData.syncState.get(LanguageSpecResult.class);
+ if (spec == null) {
+ return null;
+ }
+ return spec.spec;
}
}
diff --git a/base/src/com/google/idea/blaze/base/model/BlazeProjectData.java b/base/src/com/google/idea/blaze/base/model/BlazeProjectData.java
index 84f6936..4a401c8 100644
--- a/base/src/com/google/idea/blaze/base/model/BlazeProjectData.java
+++ b/base/src/com/google/idea/blaze/base/model/BlazeProjectData.java
@@ -22,51 +22,46 @@
import com.google.idea.blaze.base.sync.projectview.WorkspaceLanguageSettings;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
import com.google.idea.blaze.base.sync.workspace.BlazeRoots;
-import com.google.idea.blaze.base.sync.workspace.WorkingSet;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
import java.io.Serializable;
-import javax.annotation.Nullable;
import javax.annotation.concurrent.Immutable;
/** The top-level object serialized to cache. */
@Immutable
public class BlazeProjectData implements Serializable {
- private static final long serialVersionUID = 25L;
+ private static final long serialVersionUID = 27L;
public final long syncTime;
public final TargetMap targetMap;
public final ImmutableMap<String, String> blazeInfo;
public final BlazeRoots blazeRoots;
- @Nullable public final WorkingSet workingSet;
+ public final BlazeVersionData blazeVersionData;
public final WorkspacePathResolver workspacePathResolver;
public final ArtifactLocationDecoder artifactLocationDecoder;
public final WorkspaceLanguageSettings workspaceLanguageSettings;
public final SyncState syncState;
public final ImmutableMultimap<TargetKey, TargetKey> reverseDependencies;
- @Nullable public final String vcsName;
public BlazeProjectData(
long syncTime,
TargetMap targetMap,
ImmutableMap<String, String> blazeInfo,
BlazeRoots blazeRoots,
- @Nullable WorkingSet workingSet,
+ BlazeVersionData blazeVersionData,
WorkspacePathResolver workspacePathResolver,
ArtifactLocationDecoder artifactLocationDecoder,
- WorkspaceLanguageSettings workspaceLangaugeSettings,
+ WorkspaceLanguageSettings workspaceLanguageSettings,
SyncState syncState,
- ImmutableMultimap<TargetKey, TargetKey> reverseDependencies,
- String vcsName) {
+ ImmutableMultimap<TargetKey, TargetKey> reverseDependencies) {
this.syncTime = syncTime;
this.targetMap = targetMap;
this.blazeInfo = blazeInfo;
this.blazeRoots = blazeRoots;
- this.workingSet = workingSet;
+ this.blazeVersionData = blazeVersionData;
this.workspacePathResolver = workspacePathResolver;
this.artifactLocationDecoder = artifactLocationDecoder;
- this.workspaceLanguageSettings = workspaceLangaugeSettings;
+ this.workspaceLanguageSettings = workspaceLanguageSettings;
this.syncState = syncState;
this.reverseDependencies = reverseDependencies;
- this.vcsName = vcsName;
}
}
diff --git a/base/src/com/google/idea/blaze/base/model/BlazeVersionData.java b/base/src/com/google/idea/blaze/base/model/BlazeVersionData.java
new file mode 100644
index 0000000..1cbdbff
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/model/BlazeVersionData.java
@@ -0,0 +1,98 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.model;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableMap;
+import com.google.idea.blaze.base.bazel.BazelVersion;
+import com.google.idea.blaze.base.bazel.BuildSystemProvider;
+import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
+import java.io.Serializable;
+import javax.annotation.Nullable;
+
+/**
+ * Version data about the user's blaze/bazel and other info needed for switching behaviour
+ * dynamically.
+ */
+public class BlazeVersionData implements Serializable {
+ private static final long serialVersionUID = 2L;
+
+ @Nullable private final Long blazeCl;
+ @Nullable private final Long clientCl;
+ @Nullable private final BazelVersion bazelVersion;
+
+ @VisibleForTesting
+ public BlazeVersionData() {
+ this(null, null, null);
+ }
+
+ private BlazeVersionData(
+ @Nullable Long blazeCl, @Nullable Long clientCl, @Nullable BazelVersion bazelVersion) {
+ this.blazeCl = blazeCl;
+ this.clientCl = clientCl;
+ this.bazelVersion = bazelVersion;
+ }
+
+ public boolean blazeContainsCl(long cl) {
+ return blazeCl != null && blazeCl >= cl;
+ }
+
+ public boolean blazeClientIsAtLeastCl(long cl) {
+ return clientCl != null && clientCl >= cl;
+ }
+
+ public boolean bazelIsAtLeastVersion(int major, int minor, int bugfix) {
+ return bazelVersion != null && bazelVersion.isAtLeast(major, minor, bugfix);
+ }
+
+ public static BlazeVersionData build(
+ BuildSystem buildSystem,
+ WorkspaceRoot workspaceRoot,
+ ImmutableMap<String, String> blazeInfo) {
+ Builder builder = new Builder();
+ for (BuildSystemProvider provider : BuildSystemProvider.EP_NAME.getExtensions()) {
+ provider.populateBlazeVersionData(buildSystem, workspaceRoot, blazeInfo, builder);
+ }
+ return builder.build();
+ }
+
+ /** Builder class for constructing the blaze version data */
+ public static class Builder {
+ public Long blazeCl;
+ public Long clientCl;
+ public BazelVersion bazelVersion;
+
+ public Builder setBlazeCl(Long blazeCl) {
+ this.blazeCl = blazeCl;
+ return this;
+ }
+
+ public Builder setClientCl(Long clientCl) {
+ this.clientCl = clientCl;
+ return this;
+ }
+
+ public Builder setBazelVersion(BazelVersion bazelVersion) {
+ this.bazelVersion = bazelVersion;
+ return this;
+ }
+
+ public BlazeVersionData build() {
+ return new BlazeVersionData(blazeCl, clientCl, bazelVersion);
+ }
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/model/primitives/Kind.java b/base/src/com/google/idea/blaze/base/model/primitives/Kind.java
index 88d5199..206a73e 100644
--- a/base/src/com/google/idea/blaze/base/model/primitives/Kind.java
+++ b/base/src/com/google/idea/blaze/base/model/primitives/Kind.java
@@ -49,6 +49,13 @@
PY_TEST("py_test", LanguageClass.PYTHON),
PY_APPENGINE_BINARY("py_appengine_binary", LanguageClass.PYTHON),
PY_WRAP_CC("py_wrap_cc", LanguageClass.PYTHON),
+ GO_TEST("go_test", LanguageClass.GO),
+ GO_APPENGINE_TEST("go_appengine_test", LanguageClass.GO),
+ GO_BINARY("go_binary", LanguageClass.GO),
+ GO_APPENGINE_BINARY("go_appengine_binary", LanguageClass.GO),
+ GO_LIBRARY("go_library", LanguageClass.GO),
+ GO_APPENGINE_LIBRARY("go_appengine_library", LanguageClass.GO),
+ GO_WRAP_CC("go_wrap_cc", LanguageClass.GO),
;
static final ImmutableMap<String, Kind> STRING_TO_KIND = makeStringToKindMap();
diff --git a/base/src/com/google/idea/blaze/base/model/primitives/LanguageClass.java b/base/src/com/google/idea/blaze/base/model/primitives/LanguageClass.java
index 9addd48..cf030a2 100644
--- a/base/src/com/google/idea/blaze/base/model/primitives/LanguageClass.java
+++ b/base/src/com/google/idea/blaze/base/model/primitives/LanguageClass.java
@@ -28,6 +28,7 @@
JAVASCRIPT("javascript", ImmutableSet.of("js", "applejs")),
TYPESCRIPT("typescript", ImmutableSet.of("ts", "ats")),
DART("dart", ImmutableSet.of("dart")),
+ GO("go", ImmutableSet.of("go")),
PYTHON("python", ImmutableSet.of("py", "pyw"));
private static final ImmutableMap<String, LanguageClass> RECOGNIZED_EXTENSIONS =
diff --git a/base/src/com/google/idea/blaze/base/model/primitives/WorkspaceType.java b/base/src/com/google/idea/blaze/base/model/primitives/WorkspaceType.java
index 290118b..c88ad5a 100644
--- a/base/src/com/google/idea/blaze/base/model/primitives/WorkspaceType.java
+++ b/base/src/com/google/idea/blaze/base/model/primitives/WorkspaceType.java
@@ -15,6 +15,8 @@
*/
package com.google.idea.blaze.base.model.primitives;
+import com.google.common.collect.ImmutableSet;
+
/**
* Workspace types.
*
@@ -27,22 +29,23 @@
JAVA("java", LanguageClass.JAVA),
PYTHON("python", LanguageClass.PYTHON),
JAVASCRIPT("javascript", LanguageClass.JAVASCRIPT),
+ GO("go", LanguageClass.GO),
INTELLIJ_PLUGIN("intellij_plugin", LanguageClass.JAVA);
private final String name;
// the languages active by default for this WorkspaceType
- private final LanguageClass[] languages;
+ private final ImmutableSet<LanguageClass> languages;
WorkspaceType(String name, LanguageClass... languages) {
this.name = name;
- this.languages = languages;
+ this.languages = ImmutableSet.copyOf(languages);
}
public String getName() {
return name;
}
- public LanguageClass[] getLanguages() {
+ public ImmutableSet<LanguageClass> getLanguages() {
return languages;
}
diff --git a/base/src/com/google/idea/blaze/base/projectview/ProjectViewVerifier.java b/base/src/com/google/idea/blaze/base/projectview/ProjectViewVerifier.java
index 553900d..0953d07 100644
--- a/base/src/com/google/idea/blaze/base/projectview/ProjectViewVerifier.java
+++ b/base/src/com/google/idea/blaze/base/projectview/ProjectViewVerifier.java
@@ -18,7 +18,6 @@
import com.google.common.collect.Lists;
import com.google.idea.blaze.base.io.FileAttributeProvider;
import com.google.idea.blaze.base.model.primitives.WorkspacePath;
-import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import com.google.idea.blaze.base.projectview.section.ListSection;
import com.google.idea.blaze.base.projectview.section.sections.DirectoryEntry;
import com.google.idea.blaze.base.projectview.section.sections.DirectorySection;
@@ -27,7 +26,9 @@
import com.google.idea.blaze.base.scope.output.IssueOutput;
import com.google.idea.blaze.base.sync.BlazeSyncPlugin;
import com.google.idea.blaze.base.sync.projectview.WorkspaceLanguageSettings;
+import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
import com.intellij.openapi.util.io.FileUtil;
+import java.io.File;
import java.util.List;
/** Verifies project views. */
@@ -44,16 +45,7 @@
/** Verifies the project view. Any errors are output to the context as issues. */
public static boolean verifyProjectView(
BlazeContext context,
- WorkspaceRoot workspaceRoot,
- ProjectViewSet projectViewSet,
- WorkspaceLanguageSettings workspaceLanguageSettings) {
- return verifyProjectViewNoDisk(context, projectViewSet, workspaceLanguageSettings)
- && verifyIncludedPackagesExistOnDisk(context, workspaceRoot, projectViewSet);
- }
-
- /** Verifies the project view, without hitting disk. */
- public static boolean verifyProjectViewNoDisk(
- BlazeContext context,
+ WorkspacePathResolver workspacePathResolver,
ProjectViewSet projectViewSet,
WorkspaceLanguageSettings workspaceLanguageSettings) {
if (!verifyIncludedPackagesAreNotExcluded(context, projectViewSet)) {
@@ -69,6 +61,9 @@
.inFile(projectViewSet.getTopLevelProjectViewFile().projectViewFile)
.submit(context);
}
+ if (!verifyIncludedPackagesExistOnDisk(context, workspacePathResolver, projectViewSet)) {
+ return false;
+ }
return true;
}
@@ -119,7 +114,9 @@
}
private static boolean verifyIncludedPackagesExistOnDisk(
- BlazeContext context, WorkspaceRoot workspaceRoot, ProjectViewSet projectViewSet) {
+ BlazeContext context,
+ WorkspacePathResolver workspacePathResolver,
+ ProjectViewSet projectViewSet) {
boolean ok = true;
FileAttributeProvider fileAttributeProvider = FileAttributeProvider.getInstance();
@@ -135,12 +132,19 @@
continue;
}
WorkspacePath workspacePath = entry.directory;
- if (!fileAttributeProvider.exists(workspaceRoot.fileForPath(workspacePath))) {
+ File file = workspacePathResolver.resolveToFile(workspacePath);
+ if (!fileAttributeProvider.exists(file)) {
IssueOutput.error(
String.format(
- "Directory '%s' specified in import roots not found "
- + "under workspace root '%s'",
- workspacePath, workspaceRoot))
+ "Directory '%s' specified in project view not found.", workspacePath))
+ .inFile(projectViewFile.projectViewFile)
+ .withData(new MissingDirectoryIssueData(workspacePath))
+ .submit(context);
+ ok = false;
+ } else if (!fileAttributeProvider.isDirectory(file)) {
+ IssueOutput.error(
+ String.format(
+ "Directory '%s' specified in project view is a file.", workspacePath))
.inFile(projectViewFile.projectViewFile)
.withData(new MissingDirectoryIssueData(workspacePath))
.submit(context);
diff --git a/base/src/com/google/idea/blaze/base/projectview/section/sections/RunConfigurationsSection.java b/base/src/com/google/idea/blaze/base/projectview/section/sections/RunConfigurationsSection.java
new file mode 100644
index 0000000..9ffda84
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/projectview/section/sections/RunConfigurationsSection.java
@@ -0,0 +1,63 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.projectview.section.sections;
+
+import com.google.common.collect.Lists;
+import com.google.idea.blaze.base.model.primitives.WorkspacePath;
+import com.google.idea.blaze.base.projectview.parser.ParseContext;
+import com.google.idea.blaze.base.projectview.parser.ProjectViewParser;
+import com.google.idea.blaze.base.projectview.section.ListSection;
+import com.google.idea.blaze.base.projectview.section.ListSectionParser;
+import com.google.idea.blaze.base.projectview.section.SectionKey;
+import com.google.idea.blaze.base.projectview.section.SectionParser;
+import com.google.idea.blaze.base.ui.BlazeValidationError;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/** Allows users to import run configurations from XML files in their workspace. */
+public class RunConfigurationsSection {
+ public static final SectionKey<WorkspacePath, ListSection<WorkspacePath>> KEY =
+ SectionKey.of("import_run_configurations");
+ public static final SectionParser PARSER = new RunConfigurationsSectionParser();
+
+ private static class RunConfigurationsSectionParser extends ListSectionParser<WorkspacePath> {
+ private RunConfigurationsSectionParser() {
+ super(KEY);
+ }
+
+ @Nullable
+ @Override
+ protected WorkspacePath parseItem(ProjectViewParser parser, ParseContext parseContext) {
+ String text = parseContext.current().text;
+ List<BlazeValidationError> errors = Lists.newArrayList();
+ if (!WorkspacePath.validate(text, errors)) {
+ parseContext.addErrors(errors);
+ return null;
+ }
+ return new WorkspacePath(text);
+ }
+
+ @Override
+ protected void printItem(WorkspacePath item, StringBuilder sb) {
+ sb.append(item);
+ }
+
+ @Override
+ public ItemType getItemType() {
+ return ItemType.FileSystemItem;
+ }
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/projectview/section/sections/Sections.java b/base/src/com/google/idea/blaze/base/projectview/section/sections/Sections.java
index 93b2fd9..ad0c35e 100644
--- a/base/src/com/google/idea/blaze/base/projectview/section/sections/Sections.java
+++ b/base/src/com/google/idea/blaze/base/projectview/section/sections/Sections.java
@@ -36,7 +36,8 @@
ImportTargetOutputSection.PARSER,
ExcludeTargetSection.PARSER,
ExcludedSourceSection.PARSER,
- MetricsProjectSection.PARSER);
+ MetricsProjectSection.PARSER,
+ RunConfigurationsSection.PARSER);
public static List<SectionParser> getParsers() {
List<SectionParser> parsers = Lists.newArrayList(PARSERS);
diff --git a/base/src/com/google/idea/blaze/base/run/BlazeBeforeRunTaskProvider.java b/base/src/com/google/idea/blaze/base/run/BlazeBeforeRunTaskProvider.java
index 7eb51e3..9b5e0e1 100644
--- a/base/src/com/google/idea/blaze/base/run/BlazeBeforeRunTaskProvider.java
+++ b/base/src/com/google/idea/blaze/base/run/BlazeBeforeRunTaskProvider.java
@@ -20,6 +20,7 @@
import com.intellij.execution.BeforeRunTask;
import com.intellij.execution.BeforeRunTaskProvider;
import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.configurations.WrappingRunConfiguration;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.actionSystem.DataContext;
import com.intellij.openapi.util.Key;
@@ -91,6 +92,9 @@
@Override
public boolean canExecuteTask(RunConfiguration configuration, Task task) {
+ if (configuration instanceof WrappingRunConfiguration) {
+ configuration = ((WrappingRunConfiguration) configuration).getPeer();
+ }
return configuration instanceof BlazeCommandRunConfiguration;
}
diff --git a/base/src/com/google/idea/blaze/base/run/BlazeCommandRunConfiguration.java b/base/src/com/google/idea/blaze/base/run/BlazeCommandRunConfiguration.java
index d6200ee..07fd7e3 100644
--- a/base/src/com/google/idea/blaze/base/run/BlazeCommandRunConfiguration.java
+++ b/base/src/com/google/idea/blaze/base/run/BlazeCommandRunConfiguration.java
@@ -36,18 +36,21 @@
import com.intellij.execution.RunnerIconProvider;
import com.intellij.execution.configurations.ConfigurationFactory;
import com.intellij.execution.configurations.LocatableConfigurationBase;
+import com.intellij.execution.configurations.ModuleRunProfile;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.configurations.RunProfileState;
import com.intellij.execution.configurations.RuntimeConfigurationError;
import com.intellij.execution.configurations.RuntimeConfigurationException;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.module.Module;
import com.intellij.openapi.options.SettingsEditor;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.InvalidDataException;
import com.intellij.openapi.util.WriteExternalException;
import com.intellij.ui.TextFieldWithAutoCompletion;
import com.intellij.ui.TextFieldWithAutoCompletion.StringsCompletionProvider;
+import com.intellij.ui.components.JBCheckBox;
import com.intellij.ui.components.JBLabel;
import com.intellij.util.ui.UIUtil;
import java.util.Collection;
@@ -63,13 +66,15 @@
/** A run configuration which executes Blaze commands. */
public class BlazeCommandRunConfiguration extends LocatableConfigurationBase
- implements BlazeRunConfiguration, RunnerIconProvider {
+ implements BlazeRunConfiguration, RunnerIconProvider, ModuleRunProfile {
private static final Logger LOG = Logger.getInstance(BlazeCommandRunConfiguration.class);
private static final String HANDLER_ATTR = "handler-id";
private static final String TARGET_TAG = "blaze-target";
private static final String KIND_ATTR = "kind";
+ private static final String KEEP_IN_SYNC_TAG = "keep-in-sync";
+
/**
* This tag is actually written by {@link com.intellij.execution.impl.RunManagerImpl}; it
* represents the before-run tasks of the configuration. We need to know about it to avoid writing
@@ -83,6 +88,10 @@
@Nullable private TargetExpression target;
// Null if the target is null, not a Label, or not a known rule.
@Nullable private Kind targetKind;
+
+ // for keeping imported configurations in sync with their source XML
+ @Nullable private Boolean keepInSync = null;
+
private BlazeCommandRunConfigurationHandlerProvider handlerProvider;
private BlazeCommandRunConfigurationHandler handler;
@@ -118,6 +127,17 @@
}
@Override
+ public void setKeepInSync(@Nullable Boolean keepInSync) {
+ this.keepInSync = keepInSync;
+ }
+
+ @Override
+ @Nullable
+ public Boolean getKeepInSync() {
+ return keepInSync;
+ }
+
+ @Override
@Nullable
public TargetExpression getTarget() {
return target;
@@ -125,6 +145,10 @@
public void setTarget(@Nullable TargetExpression target) {
this.target = target;
+ updateHandler();
+ }
+
+ private void updateHandler() {
targetKind = getKindForTarget();
BlazeCommandRunConfigurationHandlerProvider handlerProvider =
@@ -208,6 +232,9 @@
super.readExternal(element);
element = element.clone();
+ String keepInSyncString = element.getAttributeValue(KEEP_IN_SYNC_TAG);
+ keepInSync = keepInSyncString != null ? Boolean.parseBoolean(keepInSyncString) : null;
+
// Target is persisted as a tag to permit multiple targets in the future.
Element targetElement = element.getChild(TARGET_TAG);
if (targetElement != null && !Strings.isNullOrEmpty(targetElement.getTextTrim())) {
@@ -234,6 +261,7 @@
element.removeAttribute(KIND_ATTR);
element.removeAttribute(HANDLER_ATTR);
element.removeChildren(TARGET_TAG);
+ element.removeAttribute(KEEP_IN_SYNC_TAG);
// remove legacy attribute, if present
element.removeAttribute(TARGET_TAG);
@@ -253,7 +281,11 @@
}
element.addContent(targetElement);
}
+ if (keepInSync != null) {
+ element.setAttribute(KEEP_IN_SYNC_TAG, Boolean.toString(keepInSync));
+ }
element.setAttribute(HANDLER_ATTR, handlerProvider.getId());
+
handler.getState().writeExternal(elementState);
// copy our internal state to the provided Element, skipping items already present
@@ -283,6 +315,7 @@
configuration.elementState = elementState.clone();
configuration.target = target;
configuration.targetKind = targetKind;
+ configuration.keepInSync = keepInSync;
configuration.handlerProvider = handlerProvider;
configuration.handler = handlerProvider.createHandler(this);
try {
@@ -298,6 +331,11 @@
@Nullable
public RunProfileState getState(Executor executor, ExecutionEnvironment environment)
throws ExecutionException {
+ if (target != null) {
+ // We need to update the handler manually because it might otherwise be out of date (e.g.
+ // because the target map has changed since the last update).
+ updateHandler();
+ }
BlazeCommandRunConfigurationRunner runner = handler.createRunner(executor, environment);
if (runner != null) {
environment.putCopyableUserData(BlazeCommandRunConfigurationRunner.RUNNER_KEY, runner);
@@ -323,6 +361,11 @@
return new BlazeCommandRunConfigurationSettingsEditor(this);
}
+ @Override
+ public Module[] getModules() {
+ return new Module[0];
+ }
+
static class BlazeCommandRunConfigurationSettingsEditor
extends SettingsEditor<BlazeCommandRunConfiguration> {
@@ -332,7 +375,9 @@
private JComponent handlerStateComponent;
private Element elementState;
+ private final Box editorWithoutSyncCheckBox;
private final Box editor;
+ private final JBCheckBox keepInSyncCheckBox;
private final JBLabel targetExpressionLabel;
private final TextFieldWithAutoCompletion<String> targetField;
@@ -343,16 +388,35 @@
project, new TargetCompletionProvider(project), true, null);
elementState = config.elementState.clone();
targetExpressionLabel = new JBLabel(UIUtil.ComponentStyle.LARGE);
- editor = UiUtil.createBox(targetExpressionLabel, targetField);
- updateTargetExpressionLabel(config);
+ keepInSyncCheckBox = new JBCheckBox("Keep in sync with source XML");
+ editorWithoutSyncCheckBox = UiUtil.createBox(targetExpressionLabel, targetField);
+ editor = UiUtil.createBox(editorWithoutSyncCheckBox, keepInSyncCheckBox);
+ updateEditor(config);
updateHandlerEditor(config);
+ keepInSyncCheckBox.addItemListener(e -> updateEnabledStatus());
}
- private void updateTargetExpressionLabel(BlazeCommandRunConfiguration config) {
+ private void updateEditor(BlazeCommandRunConfiguration config) {
targetExpressionLabel.setText(
String.format(
"Target expression (%s handled by %s):",
config.getTargetKindName(), config.handler.getHandlerName()));
+ keepInSyncCheckBox.setVisible(config.keepInSync != null);
+ if (config.keepInSync != null) {
+ keepInSyncCheckBox.setSelected(config.keepInSync);
+ }
+ updateEnabledStatus();
+ }
+
+ private void updateEnabledStatus() {
+ setEnabled(!keepInSyncCheckBox.isVisible() || !keepInSyncCheckBox.isSelected());
+ }
+
+ private void setEnabled(boolean enabled) {
+ if (handlerStateEditor != null) {
+ handlerStateEditor.setComponentEnabled(enabled);
+ }
+ targetField.setEnabled(enabled);
}
private void updateHandlerEditor(BlazeCommandRunConfiguration config) {
@@ -366,10 +430,10 @@
handlerStateEditor = handler.getState().getEditor(config.getProject());
if (handlerStateComponent != null) {
- editor.remove(handlerStateComponent);
+ editorWithoutSyncCheckBox.remove(handlerStateComponent);
}
handlerStateComponent = handlerStateEditor.createComponent();
- editor.add(handlerStateComponent);
+ editorWithoutSyncCheckBox.add(handlerStateComponent);
}
@Override
@@ -380,7 +444,7 @@
@Override
protected void resetEditorFrom(BlazeCommandRunConfiguration config) {
elementState = config.elementState.clone();
- updateTargetExpressionLabel(config);
+ updateEditor(config);
if (config.handlerProvider != handlerProvider) {
updateHandlerEditor(config);
}
@@ -397,6 +461,7 @@
} catch (WriteExternalException e) {
LOG.error(e);
}
+ config.keepInSync = keepInSyncCheckBox.isVisible() ? keepInSyncCheckBox.isSelected() : null;
// now set the config's state, based on the editor's (possibly out of date) handler
config.updateHandlerIfDifferentProvider(handlerProvider);
@@ -411,7 +476,7 @@
String targetString = targetField.getText();
config.setTarget(
Strings.isNullOrEmpty(targetString) ? null : TargetExpression.fromString(targetString));
- updateTargetExpressionLabel(config);
+ updateEditor(config);
if (config.handlerProvider != handlerProvider) {
updateHandlerEditor(config);
handlerStateEditor.resetEditorFrom(config.handler.getState());
diff --git a/base/src/com/google/idea/blaze/base/run/BlazeRunConfiguration.java b/base/src/com/google/idea/blaze/base/run/BlazeRunConfiguration.java
index f3409af..5a4daed 100644
--- a/base/src/com/google/idea/blaze/base/run/BlazeRunConfiguration.java
+++ b/base/src/com/google/idea/blaze/base/run/BlazeRunConfiguration.java
@@ -22,4 +22,9 @@
public interface BlazeRunConfiguration {
@Nullable
TargetExpression getTarget();
+
+ /** Keep in sync with source XML */
+ void setKeepInSync(@Nullable Boolean keepInSync);
+
+ Boolean getKeepInSync();
}
diff --git a/base/src/com/google/idea/blaze/base/run/BlazeRunConfigurationSyncListener.java b/base/src/com/google/idea/blaze/base/run/BlazeRunConfigurationSyncListener.java
index 74a3812..a1e0549 100644
--- a/base/src/com/google/idea/blaze/base/run/BlazeRunConfigurationSyncListener.java
+++ b/base/src/com/google/idea/blaze/base/run/BlazeRunConfigurationSyncListener.java
@@ -20,20 +20,28 @@
import com.google.idea.blaze.base.model.primitives.Label;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
+import com.google.idea.blaze.base.projectview.section.sections.RunConfigurationsSection;
import com.google.idea.blaze.base.projectview.section.sections.TargetSection;
+import com.google.idea.blaze.base.run.exporter.RunConfigurationSerializer;
import com.google.idea.blaze.base.scope.BlazeContext;
import com.google.idea.blaze.base.settings.BlazeImportSettings;
import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
import com.google.idea.blaze.base.sync.SyncListener;
+import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
+import com.google.idea.sdkcompat.transactions.Transactions;
import com.intellij.execution.RunManager;
import com.intellij.execution.RunnerAndConfigurationSettings;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.openapi.project.Project;
-import com.intellij.util.ui.UIUtil;
+import java.io.File;
import java.util.List;
import java.util.Set;
+import java.util.stream.Collectors;
-/** Creates run configurations for project view targets, where appropriate. */
+/**
+ * Imports run configurations specified in the project view, and creates run configurations for
+ * project view targets, where appropriate.
+ */
public class BlazeRunConfigurationSyncListener extends SyncListener.Adapter {
@Override
@@ -45,23 +53,40 @@
BlazeProjectData blazeProjectData,
SyncMode syncMode,
SyncResult syncResult) {
+ if (syncMode == SyncMode.STARTUP) {
+ return;
+ }
- UIUtil.invokeAndWaitIfNeeded(
- (Runnable)
- () -> {
- Set<Label> labelsWithConfigs = labelsWithConfigs(project);
- Set<TargetExpression> targetExpressions =
- Sets.newHashSet(projectViewSet.listItems(TargetSection.KEY));
- // We only auto-generate configurations for rules listed in the project view.
- for (TargetExpression target : targetExpressions) {
- if (!(target instanceof Label) || labelsWithConfigs.contains(target)) {
- continue;
- }
- Label label = (Label) target;
- labelsWithConfigs.add(label);
- maybeAddRunConfiguration(project, blazeProjectData, label);
- }
- });
+ Set<File> xmlFiles =
+ getImportedRunConfigurations(projectViewSet, blazeProjectData.workspacePathResolver);
+ Transactions.submitTransactionAndWait(
+ () -> {
+ // First, import from specified XML files. Then auto-generate from targets.
+ xmlFiles.forEach(
+ (file) -> RunConfigurationSerializer.loadFromXmlIgnoreExisting(project, file));
+
+ Set<Label> labelsWithConfigs = labelsWithConfigs(project);
+ Set<TargetExpression> targetExpressions =
+ Sets.newHashSet(projectViewSet.listItems(TargetSection.KEY));
+ // We only auto-generate configurations for rules listed in the project view.
+ for (TargetExpression target : targetExpressions) {
+ if (!(target instanceof Label) || labelsWithConfigs.contains(target)) {
+ continue;
+ }
+ Label label = (Label) target;
+ labelsWithConfigs.add(label);
+ maybeAddRunConfiguration(project, blazeProjectData, label);
+ }
+ });
+ }
+
+ private static Set<File> getImportedRunConfigurations(
+ ProjectViewSet projectViewSet, WorkspacePathResolver pathResolver) {
+ return projectViewSet
+ .listItems(RunConfigurationsSection.KEY)
+ .stream()
+ .map(pathResolver::resolveToFile)
+ .collect(Collectors.toSet());
}
/** Collects a set of all the Blaze labels that have an associated run configuration. */
diff --git a/base/src/com/google/idea/blaze/base/run/DistributedExecutorSupport.java b/base/src/com/google/idea/blaze/base/run/DistributedExecutorSupport.java
new file mode 100644
index 0000000..851eab6
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/DistributedExecutorSupport.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run;
+
+import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
+import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.project.Project;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/** Information about any distributed executor available to the build system. */
+public interface DistributedExecutorSupport {
+
+ ExtensionPointName<DistributedExecutorSupport> EP_NAME =
+ ExtensionPointName.create("com.google.idea.blaze.DistributedExecutorSupport");
+
+ /**
+ * Returns the name of an available distributed executor, if one exists for the given build
+ * system.
+ */
+ @Nullable
+ static DistributedExecutorSupport getAvailableExecutor(BuildSystem buildSystem) {
+ for (DistributedExecutorSupport executor : EP_NAME.getExtensions()) {
+ if (executor.isAvailable(buildSystem)) {
+ return executor;
+ }
+ }
+ return null;
+ }
+
+ /** Returns the blaze/bazel flags required to specify whether to run on a distributed executor. */
+ static List<String> getBlazeFlags(Project project, @Nullable Boolean runDistributed) {
+ if (runDistributed == null) {
+ return ImmutableList.of();
+ }
+ DistributedExecutorSupport executorInfo = getAvailableExecutor(Blaze.getBuildSystem(project));
+ if (executorInfo == null) {
+ return ImmutableList.of();
+ }
+ return ImmutableList.of(executorInfo.getBlazeFlag(runDistributed));
+ }
+
+ String executorName();
+
+ boolean isAvailable(BuildSystem buildSystem);
+
+ /** Get blaze/bazel flag specifying whether to run on this distributed executor */
+ String getBlazeFlag(boolean runDistributed);
+}
diff --git a/base/src/com/google/idea/blaze/base/run/confighandler/BlazeCommandGenericRunConfigurationHandler.java b/base/src/com/google/idea/blaze/base/run/confighandler/BlazeCommandGenericRunConfigurationHandler.java
index 0080b3f..da3d641 100644
--- a/base/src/com/google/idea/blaze/base/run/confighandler/BlazeCommandGenericRunConfigurationHandler.java
+++ b/base/src/com/google/idea/blaze/base/run/confighandler/BlazeCommandGenericRunConfigurationHandler.java
@@ -20,6 +20,7 @@
import com.google.idea.blaze.base.run.BlazeConfigurationNameBuilder;
import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.configurations.RuntimeConfigurationException;
@@ -38,8 +39,9 @@
private final BlazeCommandRunConfigurationCommonState state;
public BlazeCommandGenericRunConfigurationHandler(BlazeCommandRunConfiguration configuration) {
- this.buildSystemName = Blaze.buildSystemName(configuration.getProject());
- this.state = new BlazeCommandRunConfigurationCommonState(buildSystemName);
+ BuildSystem buildSystem = Blaze.getBuildSystem(configuration.getProject());
+ this.buildSystemName = buildSystem.getName();
+ this.state = new BlazeCommandRunConfigurationCommonState(buildSystem);
}
@Override
diff --git a/base/src/com/google/idea/blaze/base/run/confighandler/BlazeCommandGenericRunConfigurationRunner.java b/base/src/com/google/idea/blaze/base/run/confighandler/BlazeCommandGenericRunConfigurationRunner.java
index 79a5147..d2c6512 100644
--- a/base/src/com/google/idea/blaze/base/run/confighandler/BlazeCommandGenericRunConfigurationRunner.java
+++ b/base/src/com/google/idea/blaze/base/run/confighandler/BlazeCommandGenericRunConfigurationRunner.java
@@ -18,6 +18,7 @@
import com.google.common.collect.ImmutableList;
import com.google.idea.blaze.base.async.process.LineProcessingOutputStream;
import com.google.idea.blaze.base.command.BlazeCommand;
+import com.google.idea.blaze.base.command.BlazeCommandName;
import com.google.idea.blaze.base.command.BlazeFlags;
import com.google.idea.blaze.base.issueparser.IssueOutputLineProcessor;
import com.google.idea.blaze.base.metrics.Action;
@@ -25,8 +26,12 @@
import com.google.idea.blaze.base.projectview.ProjectViewManager;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
+import com.google.idea.blaze.base.run.DistributedExecutorSupport;
import com.google.idea.blaze.base.run.processhandler.LineProcessingProcessAdapter;
import com.google.idea.blaze.base.run.processhandler.ScopedBlazeProcessHandler;
+import com.google.idea.blaze.base.run.smrunner.BlazeTestEventsHandler;
+import com.google.idea.blaze.base.run.smrunner.BlazeTestEventsHandlerProvider;
+import com.google.idea.blaze.base.run.smrunner.SmRunnerUtils;
import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
import com.google.idea.blaze.base.scope.BlazeContext;
import com.google.idea.blaze.base.scope.scopes.IdeaLogScope;
@@ -35,15 +40,22 @@
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.settings.BlazeImportSettings;
import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
+import com.intellij.execution.DefaultExecutionResult;
import com.intellij.execution.ExecutionException;
+import com.intellij.execution.ExecutionResult;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.CommandLineState;
import com.intellij.execution.configurations.RunProfile;
import com.intellij.execution.configurations.RunProfileState;
+import com.intellij.execution.configurations.WrappingRunConfiguration;
+import com.intellij.execution.filters.TextConsoleBuilderImpl;
import com.intellij.execution.process.ProcessHandler;
import com.intellij.execution.process.ProcessListener;
import com.intellij.execution.runners.ExecutionEnvironment;
+import com.intellij.execution.runners.ProgramRunner;
+import com.intellij.execution.ui.ConsoleView;
import com.intellij.openapi.project.Project;
+import javax.annotation.Nullable;
import org.jetbrains.annotations.NotNull;
/**
@@ -55,7 +67,7 @@
@Override
public RunProfileState getRunProfileState(Executor executor, ExecutionEnvironment environment) {
- return new BlazeCommandRunProfileState(environment);
+ return new BlazeCommandRunProfileState(environment, null);
}
@Override
@@ -68,13 +80,31 @@
public static class BlazeCommandRunProfileState extends CommandLineState {
private final BlazeCommandRunConfiguration configuration;
private final BlazeCommandRunConfigurationCommonState handlerState;
+ @Nullable private final BlazeTestEventsHandlerProvider testEventsHandlerProvider;
- public BlazeCommandRunProfileState(ExecutionEnvironment environment) {
+ public BlazeCommandRunProfileState(
+ ExecutionEnvironment environment,
+ @Nullable BlazeTestEventsHandlerProvider testEventsHandlerProvider) {
super(environment);
- RunProfile runProfile = environment.getRunProfile();
- configuration = (BlazeCommandRunConfiguration) runProfile;
- handlerState =
+ this.configuration = getConfiguration(environment);
+ this.handlerState =
(BlazeCommandRunConfigurationCommonState) configuration.getHandler().getState();
+ this.testEventsHandlerProvider = testEventsHandlerProvider;
+ }
+
+ private static BlazeCommandRunConfiguration getConfiguration(ExecutionEnvironment environment) {
+ RunProfile runProfile = environment.getRunProfile();
+ if (runProfile instanceof WrappingRunConfiguration) {
+ runProfile = ((WrappingRunConfiguration) runProfile).getPeer();
+ }
+ return (BlazeCommandRunConfiguration) runProfile;
+ }
+
+ @Override
+ public ExecutionResult execute(Executor executor, ProgramRunner runner)
+ throws ExecutionException {
+ DefaultExecutionResult result = (DefaultExecutionResult) super.execute(executor, runner);
+ return SmRunnerUtils.attachRerunFailedTestsAction(result);
}
@Override
@@ -88,14 +118,24 @@
ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
assert projectViewSet != null;
- BlazeCommand blazeCommand =
- BlazeCommand.builder(Blaze.getBuildSystem(project), handlerState.getCommand())
- .setBlazeBinary(handlerState.getBlazeBinary())
- .addTargets(configuration.getTarget())
- .addBlazeFlags(BlazeFlags.buildFlags(project, projectViewSet))
- .addBlazeFlags(handlerState.getBlazeFlags())
- .addExeFlags(handlerState.getExeFlags())
- .build();
+ ImmutableList<String> testHandlerFlags = ImmutableList.of();
+ BlazeTestEventsHandler testEventsHandler =
+ canUseTestUi() && testEventsHandlerProvider != null
+ ? testEventsHandlerProvider.getHandler()
+ : null;
+ if (testEventsHandler != null) {
+ testHandlerFlags = testEventsHandler.getBlazeFlags();
+ setConsoleBuilder(
+ new TextConsoleBuilderImpl(project) {
+ @Override
+ protected ConsoleView createConsole() {
+ return SmRunnerUtils.getConsoleView(
+ project, configuration, getEnvironment().getExecutor(), testEventsHandler);
+ }
+ });
+ }
+
+ BlazeCommand blazeCommand = getBlazeCommand(project, testHandlerFlags);
WorkspaceRoot workspaceRoot = WorkspaceRoot.fromImportSettings(importSettings);
return new ScopedBlazeProcessHandler(
@@ -120,5 +160,28 @@
}
});
}
+
+ private BlazeCommand getBlazeCommand(Project project, ImmutableList<String> testHandlerFlags) {
+ ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
+ assert projectViewSet != null;
+
+ return BlazeCommand.builder(Blaze.getBuildSystem(project), handlerState.getCommand())
+ .setBlazeBinary(handlerState.getBlazeBinary())
+ .addTargets(configuration.getTarget())
+ .addBlazeFlags(BlazeFlags.buildFlags(project, projectViewSet))
+ .addBlazeFlags(testHandlerFlags)
+ .addBlazeFlags(handlerState.getBlazeFlags())
+ .addBlazeFlags(
+ DistributedExecutorSupport.getBlazeFlags(
+ project, handlerState.getRunOnDistributedExecutor()))
+ .addExeFlags(handlerState.getExeFlags())
+ .build();
+ }
+
+ private boolean canUseTestUi() {
+ return testEventsHandlerProvider != null
+ && BlazeCommandName.TEST.equals(handlerState.getCommand())
+ && !Boolean.TRUE.equals(handlerState.getRunOnDistributedExecutor());
+ }
}
}
diff --git a/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationAction.java b/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationAction.java
new file mode 100644
index 0000000..bc97225
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationAction.java
@@ -0,0 +1,46 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.exporter;
+
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
+import com.google.idea.blaze.base.run.BlazeRunConfiguration;
+import com.intellij.execution.RunManager;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.project.DumbAware;
+import com.intellij.openapi.project.Project;
+
+/**
+ * Export selected run configurations to file, so they can be checked in and shared between users.
+ */
+public class ExportRunConfigurationAction extends BlazeProjectAction implements DumbAware {
+
+ @Override
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
+ boolean hasBlazeConfigs =
+ RunManager.getInstance(project)
+ .getAllConfigurationsList()
+ .stream()
+ .anyMatch((config) -> config instanceof BlazeRunConfiguration);
+ if (!hasBlazeConfigs) {
+ e.getPresentation().setEnabled(false);
+ }
+ }
+
+ @Override
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
+ new ExportRunConfigurationDialog(project).show();
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationDialog.java b/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationDialog.java
new file mode 100644
index 0000000..c4802c1
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationDialog.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.exporter;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.base.io.FileAttributeProvider;
+import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
+import com.google.idea.blaze.base.projectview.ProjectViewManager;
+import com.google.idea.blaze.base.projectview.ProjectViewSet;
+import com.google.idea.blaze.base.projectview.ProjectViewSet.ProjectViewFile;
+import com.google.idea.blaze.base.run.BlazeRunConfiguration;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.intellij.execution.RunManager;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.icons.AllIcons;
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.Presentation;
+import com.intellij.openapi.fileChooser.FileChooserDescriptor;
+import com.intellij.openapi.fileChooser.FileChooserDescriptorFactory;
+import com.intellij.openapi.fileChooser.FileChooserDialog;
+import com.intellij.openapi.fileChooser.FileChooserFactory;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.ui.DialogWrapper;
+import com.intellij.openapi.ui.ValidationInfo;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.ui.AnActionButton;
+import com.intellij.ui.BooleanTableCellEditor;
+import com.intellij.ui.BooleanTableCellRenderer;
+import com.intellij.ui.ColoredTableCellRenderer;
+import com.intellij.ui.FieldPanel;
+import com.intellij.ui.GuiUtils;
+import com.intellij.ui.IdeBorderFactory;
+import com.intellij.ui.ToolbarDecorator;
+import com.intellij.ui.table.JBTable;
+import java.awt.BorderLayout;
+import java.awt.Dimension;
+import java.awt.event.ActionListener;
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.stream.Collectors;
+import javax.annotation.Nullable;
+import javax.swing.DefaultCellEditor;
+import javax.swing.JComponent;
+import javax.swing.JPanel;
+import javax.swing.JTable;
+import javax.swing.table.TableColumn;
+import org.jdom.output.Format;
+import org.jdom.output.XMLOutputter;
+
+/** UI for exporting blaze run configurations. */
+public class ExportRunConfigurationDialog extends DialogWrapper {
+
+ private final ImmutableList<RunConfiguration> blazeConfigurations;
+ private final ExportRunConfigurationTableModel tableModel;
+ private final JBTable table;
+ private final FieldPanel outputDirectoryPanel;
+
+ ExportRunConfigurationDialog(Project project) {
+ super(project, true);
+ blazeConfigurations =
+ ImmutableList.copyOf(
+ RunManager.getInstance(project)
+ .getAllConfigurationsList()
+ .stream()
+ .filter((config) -> config instanceof BlazeRunConfiguration)
+ .collect(Collectors.toList()));
+ tableModel = new ExportRunConfigurationTableModel(blazeConfigurations);
+ table = new JBTable(tableModel);
+
+ TableColumn booleanColumn = table.getColumnModel().getColumn(0);
+ booleanColumn.setCellRenderer(new BooleanTableCellRenderer());
+ booleanColumn.setCellEditor(new BooleanTableCellEditor());
+ int width = table.getFontMetrics(table.getFont()).stringWidth(table.getColumnName(0)) + 10;
+ booleanColumn.setPreferredWidth(width);
+ booleanColumn.setMinWidth(width);
+ booleanColumn.setMaxWidth(width);
+
+ table
+ .getColumnModel()
+ .getColumn(2)
+ .setCellEditor(new DefaultCellEditor(GuiUtils.createUndoableTextField()));
+
+ TableColumn nameColumn = table.getColumnModel().getColumn(1);
+ nameColumn.setCellRenderer(
+ new ColoredTableCellRenderer() {
+ @Override
+ protected void customizeCellRenderer(
+ JTable table, Object value, boolean isSelected, boolean hasFocus, int row, int col) {
+ RunConfiguration config = blazeConfigurations.get(row);
+ setIcon(config.getType().getIcon());
+ append(config.getName());
+ }
+ });
+
+ table.setPreferredSize(new Dimension(700, 700));
+ table.setShowColumns(true);
+
+ final ActionListener browseAction = e -> chooseDirectory();
+ outputDirectoryPanel =
+ new FieldPanel("Export configurations to directory:", null, browseAction, null);
+ File defaultExportDirectory = defaultExportDirectory(project);
+ if (defaultExportDirectory != null) {
+ outputDirectoryPanel.setText(defaultExportDirectory.getPath());
+ }
+
+ String buildSystem = Blaze.buildSystemName(project);
+ setTitle(String.format("Export %s Run Configurations", buildSystem));
+ init();
+ }
+
+ /** Try to find a checked-in project view file. Otherwise, fall back to the workspace root. */
+ @Nullable
+ private static File defaultExportDirectory(Project project) {
+ WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProjectSafe(project);
+ if (workspaceRoot == null) {
+ return null;
+ }
+ ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
+ if (projectViewSet != null) {
+ for (ProjectViewFile projectViewFile : projectViewSet.getProjectViewFiles()) {
+ File file = projectViewFile.projectViewFile;
+ if (file != null && FileUtil.isAncestor(workspaceRoot.directory(), file, false)) {
+ return file.getParentFile();
+ }
+ }
+ }
+ return workspaceRoot.directory();
+ }
+
+ private String getOutputDirectoryPath() {
+ return Strings.nullToEmpty(outputDirectoryPanel.getText()).trim();
+ }
+
+ private void chooseDirectory() {
+ FileChooserDescriptor descriptor =
+ FileChooserDescriptorFactory.createSingleFolderDescriptor()
+ .withTitle("Export Directory Location")
+ .withDescription("Choose directory to export run configurations to")
+ .withHideIgnored(false);
+ FileChooserDialog chooser =
+ FileChooserFactory.getInstance().createFileChooser(descriptor, null, null);
+
+ final VirtualFile[] files;
+ File existingLocation = new File(getOutputDirectoryPath());
+ if (existingLocation.exists()) {
+ VirtualFile toSelect =
+ LocalFileSystem.getInstance().refreshAndFindFileByPath(existingLocation.getPath());
+ files = chooser.choose(null, toSelect);
+ } else {
+ files = chooser.choose(null);
+ }
+ if (files.length == 0) {
+ return;
+ }
+ VirtualFile file = files[0];
+ outputDirectoryPanel.setText(file.getPath());
+ }
+
+ @Nullable
+ @Override
+ protected ValidationInfo doValidate() {
+ String outputDir = getOutputDirectoryPath();
+ if (outputDir.isEmpty()) {
+ return new ValidationInfo("Choose an output directory");
+ }
+ if (!FileAttributeProvider.getInstance().exists(new File(outputDir))) {
+ return new ValidationInfo("Invalid output directory");
+ }
+ Set<String> names = new HashSet<>();
+ for (int i = 0; i < blazeConfigurations.size(); i++) {
+ if (!tableModel.enabled[i]) {
+ continue;
+ }
+ if (!names.add(tableModel.paths[i])) {
+ return new ValidationInfo("Duplicate output file name '" + tableModel.paths[i] + "'");
+ }
+ }
+ return null;
+ }
+
+ @Override
+ protected void doOKAction() {
+ File outputDir = new File(getOutputDirectoryPath());
+ List<File> outputFiles = new ArrayList<>();
+ for (int i = 0; i < blazeConfigurations.size(); i++) {
+ if (!tableModel.enabled[i]) {
+ continue;
+ }
+ File outputFile = new File(outputDir, tableModel.paths[i]);
+ writeConfiguration(blazeConfigurations.get(i), outputFile);
+ outputFiles.add(outputFile);
+ }
+ LocalFileSystem.getInstance().refreshIoFiles(outputFiles);
+ super.doOKAction();
+ }
+
+ private static void writeConfiguration(RunConfiguration configuration, File outputFile) {
+ try (FileOutputStream writer = new FileOutputStream(outputFile, false)) {
+ XMLOutputter xmlOutputter = new XMLOutputter(Format.getCompactFormat());
+ xmlOutputter.output(RunConfigurationSerializer.writeToXml(configuration), writer);
+ } catch (IOException e) {
+ throw new RuntimeException("Error exporting run configuration to file: " + outputFile);
+ }
+ }
+
+ @Override
+ protected JComponent createNorthPanel() {
+ return outputDirectoryPanel;
+ }
+
+ @Override
+ protected JComponent createCenterPanel() {
+ JPanel panel = new JPanel(new BorderLayout());
+ panel.setBorder(IdeBorderFactory.createTitledBorder("Run Configurations", false));
+ panel.add(
+ ToolbarDecorator.createDecorator(table).addExtraAction(new SelectAllButton()).createPanel(),
+ BorderLayout.CENTER);
+ return panel;
+ }
+
+ private class SelectAllButton extends AnActionButton {
+
+ boolean allSelected = false;
+
+ private SelectAllButton() {
+ super("Select All", AllIcons.Actions.Selectall);
+ }
+
+ @Override
+ public synchronized void actionPerformed(AnActionEvent anActionEvent) {
+ boolean newState = !allSelected;
+ for (int i = 0; i < tableModel.enabled.length; i++) {
+ table.setValueAt(newState, i, 0);
+ }
+ allSelected = newState;
+ Presentation presentation = anActionEvent.getPresentation();
+ if (allSelected) {
+ presentation.setText("Deselect All");
+ presentation.setIcon(AllIcons.Actions.Unselectall);
+ } else {
+ presentation.setText("Select All");
+ presentation.setIcon(AllIcons.Actions.Selectall);
+ }
+ tableModel.fireTableDataChanged();
+ table.revalidate();
+ table.repaint();
+ }
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationTableModel.java b/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationTableModel.java
new file mode 100644
index 0000000..cc00d52
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/exporter/ExportRunConfigurationTableModel.java
@@ -0,0 +1,107 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.exporter;
+
+import com.google.common.collect.ImmutableList;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.openapi.util.io.FileUtil;
+import com.intellij.util.text.UniqueNameGenerator;
+import java.util.List;
+import javax.swing.table.AbstractTableModel;
+
+/** Table model used by the 'export run configurations' UI. */
+class ExportRunConfigurationTableModel extends AbstractTableModel {
+
+ private static final ImmutableList<String> COLUMN_NAMES =
+ ImmutableList.of("Export", "Name", "Output filename");
+ private static final ImmutableList<Class<?>> COLUMN_CLASSES =
+ ImmutableList.of(Boolean.class, String.class, String.class);
+
+ final Boolean[] enabled;
+ final String[] names;
+ final String[] paths;
+
+ ExportRunConfigurationTableModel(List<RunConfiguration> configurations) {
+ enabled = new Boolean[configurations.size()];
+ names = new String[configurations.size()];
+ paths = new String[configurations.size()];
+
+ UniqueNameGenerator nameGenerator = new UniqueNameGenerator();
+ for (int i = 0; i < configurations.size(); i++) {
+ RunConfiguration config = configurations.get(i);
+ enabled[i] = false;
+ names[i] = config.getName();
+ paths[i] =
+ nameGenerator.generateUniqueName(FileUtil.sanitizeFileName(config.getName()), "", ".xml");
+ }
+ }
+
+ @Override
+ public int getColumnCount() {
+ return 3;
+ }
+
+ @Override
+ public Class<?> getColumnClass(int columnIndex) {
+ return COLUMN_CLASSES.get(columnIndex);
+ }
+
+ @Override
+ public String getColumnName(int column) {
+ return COLUMN_NAMES.get(column);
+ }
+
+ @Override
+ public int getRowCount() {
+ return enabled.length;
+ }
+
+ @Override
+ public boolean isCellEditable(int rowIndex, int columnIndex) {
+ return columnIndex != 1;
+ }
+
+ @Override
+ public Object getValueAt(int rowIndex, int columnIndex) {
+ switch (columnIndex) {
+ case 0:
+ return enabled[rowIndex];
+ case 1:
+ return names[rowIndex];
+ case 2:
+ return paths[rowIndex];
+ default:
+ throw new RuntimeException("Invalid column index: " + columnIndex);
+ }
+ }
+
+ @Override
+ public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
+ switch (columnIndex) {
+ case 0:
+ enabled[rowIndex] = (Boolean) aValue;
+ return;
+ case 1:
+ names[rowIndex] = (String) aValue;
+ return;
+ case 2:
+ paths[rowIndex] = (String) aValue;
+ return;
+ default:
+ throw new RuntimeException("Invalid column index: " + columnIndex);
+ }
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/exporter/RunConfigurationSerializer.java b/base/src/com/google/idea/blaze/base/run/exporter/RunConfigurationSerializer.java
new file mode 100644
index 0000000..aed9db4
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/exporter/RunConfigurationSerializer.java
@@ -0,0 +1,125 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.exporter;
+
+import com.google.common.annotations.VisibleForTesting;
+import com.google.idea.blaze.base.run.BlazeRunConfiguration;
+import com.intellij.execution.RunnerAndConfigurationSettings;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.impl.RunManagerImpl;
+import com.intellij.execution.impl.RunnerAndConfigurationSettingsImpl;
+import com.intellij.openapi.diagnostic.Logger;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.InvalidDataException;
+import com.intellij.openapi.util.JDOMUtil;
+import com.intellij.openapi.util.WriteExternalException;
+import java.io.File;
+import java.io.IOException;
+import javax.annotation.Nullable;
+import org.jdom.Element;
+import org.jdom.JDOMException;
+
+/** Utility methods for converting run configuration to/from XML. */
+public class RunConfigurationSerializer {
+
+ private static final Logger logger = Logger.getInstance(RunConfigurationSerializer.class);
+
+ public static Element writeToXml(RunConfiguration configuration) {
+ RunnerAndConfigurationSettings settings =
+ RunManagerImpl.getInstanceImpl(configuration.getProject()).getSettings(configuration);
+ Element element = new Element("configuration");
+ try {
+ ((RunnerAndConfigurationSettingsImpl) settings).writeExternal(element);
+ } catch (WriteExternalException e) {
+ logger.warn("Error serializing run configuration to XML", e);
+ }
+ return element;
+ }
+
+ /**
+ * Parses a RunConfiguration from the given XML file, and adds it to the project, if there's not
+ * already a run configuration with the same name and type,
+ */
+ public static void loadFromXmlIgnoreExisting(Project project, File xmlFile) {
+ try {
+ loadFromXmlElementIgnoreExisting(project, JDOMUtil.load(xmlFile));
+ } catch (InvalidDataException | JDOMException | IOException e) {
+ logger.warn("Error parsing run configuration from XML", e);
+ }
+ }
+
+ /**
+ * Parses a RunConfiguration from the given XML element, and adds it to the project, if there's
+ * not already a run configuration with the same name and type,
+ */
+ @VisibleForTesting
+ static void loadFromXmlElementIgnoreExisting(Project project, Element element)
+ throws InvalidDataException {
+ if (!shouldLoadConfiguration(project, element)) {
+ return;
+ }
+ RunnerAndConfigurationSettings settings =
+ RunManagerImpl.getInstanceImpl(project).loadConfiguration(element, false);
+ RunConfiguration config = settings != null ? settings.getConfiguration() : null;
+ if (config instanceof BlazeRunConfiguration) {
+ ((BlazeRunConfiguration) config).setKeepInSync(true);
+ }
+ }
+
+ /**
+ * Deserializes the configuration represented by the given XML element, then searches for an
+ * existing run configuration in the project with the same name and type.
+ */
+ @Nullable
+ @VisibleForTesting
+ static RunnerAndConfigurationSettings findExisting(Project project, Element element)
+ throws InvalidDataException {
+ RunManagerImpl manager = RunManagerImpl.getInstanceImpl(project);
+ RunnerAndConfigurationSettingsImpl settings = new RunnerAndConfigurationSettingsImpl(manager);
+ settings.readExternal(element);
+ RunConfiguration config = settings.getConfiguration();
+ if (config == null) {
+ return null;
+ }
+ return manager.findConfigurationByTypeAndName(config.getType().getId(), config.getName());
+ }
+
+ /**
+ * Returns true if there's either no matching configuration altready in the project, or the
+ * matching configuration is marked as 'keep in sync'.
+ */
+ @VisibleForTesting
+ static boolean shouldLoadConfiguration(Project project, Element element)
+ throws InvalidDataException {
+ RunnerAndConfigurationSettings existing = findExisting(project, element);
+ if (existing == null) {
+ return true;
+ }
+ RunConfiguration config = existing.getConfiguration();
+ if (!(config instanceof BlazeRunConfiguration)) {
+ return false;
+ }
+ BlazeRunConfiguration blazeConfig = (BlazeRunConfiguration) config;
+ Boolean keepInSync = blazeConfig.getKeepInSync();
+ if (keepInSync == null) {
+ // if the matching configuration was never previously imported, don't overwrite, but activate
+ // the UI option to keep it in sync.
+ blazeConfig.setKeepInSync(false);
+ return false;
+ }
+ return keepInSync;
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/smrunner/BlazeRerunFailedTestsAction.java b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeRerunFailedTestsAction.java
new file mode 100644
index 0000000..bc90989
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeRerunFailedTestsAction.java
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.smrunner;
+
+import com.google.idea.blaze.base.command.BlazeCommandName;
+import com.google.idea.blaze.base.command.BlazeFlags;
+import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
+import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
+import com.intellij.execution.ExecutionException;
+import com.intellij.execution.Executor;
+import com.intellij.execution.configurations.RunProfileState;
+import com.intellij.execution.runners.ExecutionEnvironment;
+import com.intellij.execution.testframework.TestFrameworkRunningModel;
+import com.intellij.execution.testframework.actions.AbstractRerunFailedTestsAction;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.ui.ComponentContainer;
+import java.util.ArrayList;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/** Re-run failed tests. */
+public class BlazeRerunFailedTestsAction extends AbstractRerunFailedTestsAction {
+
+ private final BlazeTestEventsHandler eventsHandler;
+
+ public BlazeRerunFailedTestsAction(
+ BlazeTestEventsHandler eventsHandler, ComponentContainer componentContainer) {
+ super(componentContainer);
+ this.eventsHandler = eventsHandler;
+ }
+
+ @Override
+ @Nullable
+ protected MyRunProfile getRunProfile(ExecutionEnvironment environment) {
+ final TestFrameworkRunningModel model = getModel();
+ if (model == null) {
+ return null;
+ }
+ BlazeCommandRunConfiguration config =
+ (BlazeCommandRunConfiguration) model.getProperties().getConfiguration();
+ return new BlazeRerunTestRunProfile(config.clone());
+ }
+
+ class BlazeRerunTestRunProfile extends MyRunProfile {
+
+ private final BlazeCommandRunConfiguration configuration;
+
+ BlazeRerunTestRunProfile(BlazeCommandRunConfiguration configuration) {
+ super(configuration);
+ this.configuration = configuration;
+ }
+
+ @Override
+ public Module[] getModules() {
+ return Module.EMPTY_ARRAY;
+ }
+
+ @Nullable
+ @Override
+ public RunProfileState getState(Executor executor, ExecutionEnvironment environment)
+ throws ExecutionException {
+ BlazeCommandRunConfigurationCommonState handlerState =
+ configuration.getHandlerStateIfType(BlazeCommandRunConfigurationCommonState.class);
+ if (handlerState == null || !BlazeCommandName.TEST.equals(handlerState.getCommand())) {
+ return null;
+ }
+ String testFilter = eventsHandler.getTestFilter(getProject(), getFailedTests(getProject()));
+ List<String> blazeFlags = setTestFilter(handlerState.getBlazeFlags(), testFilter);
+ handlerState.setBlazeFlags(blazeFlags);
+ return configuration.getState(executor, environment);
+ }
+
+ /** Replaces existing test_filter flag, or appends if none exists. */
+ private List<String> setTestFilter(List<String> flags, String testFilter) {
+ List<String> copy = new ArrayList<>(flags);
+ for (int i = 0; i < copy.size(); i++) {
+ String flag = copy.get(i);
+ if (flag.startsWith(BlazeFlags.TEST_FILTER)) {
+ copy.set(i, testFilter);
+ return copy;
+ }
+ }
+ copy.add(testFilter);
+ return copy;
+ }
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestConsoleProperties.java b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestConsoleProperties.java
new file mode 100644
index 0000000..6582c23
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestConsoleProperties.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.smrunner;
+
+import com.intellij.execution.Executor;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.testframework.TestConsoleProperties;
+import com.intellij.execution.testframework.actions.AbstractRerunFailedTestsAction;
+import com.intellij.execution.testframework.sm.SMCustomMessagesParsing;
+import com.intellij.execution.testframework.sm.runner.OutputToGeneralTestEventsConverter;
+import com.intellij.execution.testframework.sm.runner.SMTRunnerConsoleProperties;
+import com.intellij.execution.testframework.sm.runner.SMTestLocator;
+import com.intellij.execution.ui.ConsoleView;
+import javax.annotation.Nullable;
+
+/** Integrates blaze test results with the SM-runner test UI. */
+public class BlazeTestConsoleProperties extends SMTRunnerConsoleProperties
+ implements SMCustomMessagesParsing {
+
+ private final BlazeTestEventsHandler eventsHandler;
+
+ public BlazeTestConsoleProperties(
+ RunConfiguration runConfiguration, Executor executor, BlazeTestEventsHandler eventsHandler) {
+ super(runConfiguration, eventsHandler.frameworkName, executor);
+ this.eventsHandler = eventsHandler;
+ }
+
+ @Override
+ public OutputToGeneralTestEventsConverter createTestEventsConverter(
+ String framework, TestConsoleProperties consoleProperties) {
+ return new BlazeXmlToTestEventsConverter(framework, consoleProperties, eventsHandler);
+ }
+
+ @Override
+ public SMTestLocator getTestLocator() {
+ return eventsHandler.getTestLocator();
+ }
+
+ @Nullable
+ @Override
+ public AbstractRerunFailedTestsAction createRerunFailedTestsAction(ConsoleView consoleView) {
+ return eventsHandler.createRerunFailedTestsAction(consoleView);
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestEventsHandler.java b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestEventsHandler.java
new file mode 100644
index 0000000..87e1b7f
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestEventsHandler.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.smrunner;
+
+import com.google.common.base.Strings;
+import com.google.common.collect.ImmutableList;
+import com.intellij.execution.testframework.AbstractTestProxy;
+import com.intellij.execution.testframework.actions.AbstractRerunFailedTestsAction;
+import com.intellij.execution.testframework.sm.runner.SMTestLocator;
+import com.intellij.execution.ui.ConsoleView;
+import com.intellij.openapi.project.Project;
+import com.intellij.util.io.URLUtil;
+import java.io.File;
+import java.io.IOException;
+import java.nio.file.Files;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/** Language-specific handling of SM runner test protocol */
+public abstract class BlazeTestEventsHandler {
+
+ public final String frameworkName;
+ public final File testOutputXml;
+
+ protected BlazeTestEventsHandler(String frameworkName) {
+ this.frameworkName = frameworkName;
+ this.testOutputXml = generateTempTestXmlFile();
+ }
+
+ /**
+ * Blaze/Bazel flags required for test UI.<br>
+ * Forces local test execution, without sharding, and sets the output test xml path.
+ */
+ public ImmutableList<String> getBlazeFlags() {
+ return ImmutableList.of(
+ "--test_env=XML_OUTPUT_FILE=" + testOutputXml,
+ "--test_sharding_strategy=disabled",
+ "--runs_per_test=1",
+ "--flaky_test_attempts=1",
+ "--test_strategy=local");
+ }
+
+ public abstract SMTestLocator getTestLocator();
+
+ /**
+ * The --test_filter flag passed to blaze to rerun the given tests.
+ *
+ * @return null if no filter can be constructed for these tests.
+ */
+ @Nullable
+ public abstract String getTestFilter(Project project, List<AbstractTestProxy> failedTests);
+
+ @Nullable
+ public AbstractRerunFailedTestsAction createRerunFailedTestsAction(ConsoleView consoleView) {
+ return new BlazeRerunFailedTestsAction(this, consoleView);
+ }
+
+ /** Converts the testsuite name in the blaze test XML to a user-friendly format */
+ public String suiteDisplayName(String rawName) {
+ return rawName;
+ }
+
+ /** Converts the testcase name in the blaze test XML to a user-friendly format */
+ public String testDisplayName(String rawName) {
+ return rawName;
+ }
+
+ public String suiteLocationUrl(String name) {
+ return SmRunnerUtils.GENERIC_SUITE_PROTOCOL + URLUtil.SCHEME_SEPARATOR + name;
+ }
+
+ public String testLocationUrl(String name, @Nullable String className) {
+ String base = SmRunnerUtils.GENERIC_TEST_PROTOCOL + URLUtil.SCHEME_SEPARATOR + name;
+ if (Strings.isNullOrEmpty(className)) {
+ return base;
+ }
+ return base + SmRunnerUtils.TEST_NAME_PARTS_SPLITTER + className;
+ }
+
+ private static File generateTempTestXmlFile() {
+ try {
+ File file = Files.createTempFile("blazeTest", ".xml").toFile();
+ file.deleteOnExit();
+ return file;
+
+ } catch (IOException e) {
+ throw new RuntimeException(e);
+ }
+ }
+}
diff --git a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/InstantRunExperiment.java b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestEventsHandlerProvider.java
similarity index 61%
copy from aswb/src/com/google/idea/blaze/android/run/binary/instantrun/InstantRunExperiment.java
copy to base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestEventsHandlerProvider.java
index 148b1d9..c02a0cb 100644
--- a/aswb/src/com/google/idea/blaze/android/run/binary/instantrun/InstantRunExperiment.java
+++ b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeTestEventsHandlerProvider.java
@@ -5,7 +5,7 @@
* 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
+ * 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,
@@ -13,12 +13,10 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
-package com.google.idea.blaze.android.run.binary.instantrun;
+package com.google.idea.blaze.base.run.smrunner;
-import com.google.idea.common.experiments.BoolExperiment;
+/** Provides a {@link BlazeTestEventsHandler}. */
+public interface BlazeTestEventsHandlerProvider {
-/** Holds the instant run experiment */
-public class InstantRunExperiment {
- public static final BoolExperiment INSTANT_RUN_ENABLED =
- new BoolExperiment("instant.run.enabled", false);
+ BlazeTestEventsHandler getHandler();
}
diff --git a/base/src/com/google/idea/blaze/base/run/smrunner/BlazeXmlSchema.java b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeXmlSchema.java
new file mode 100644
index 0000000..8f6d1f0
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeXmlSchema.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.smrunner;
+
+import com.google.common.collect.Lists;
+import java.io.InputStream;
+import java.util.List;
+import javax.xml.bind.JAXBContext;
+import javax.xml.bind.JAXBException;
+import javax.xml.bind.annotation.XmlAttribute;
+import javax.xml.bind.annotation.XmlElement;
+import javax.xml.bind.annotation.XmlRootElement;
+import javax.xml.bind.annotation.XmlValue;
+
+/** Used to parse the test.xml generated by the blaze/bazel testing framework. */
+public class BlazeXmlSchema {
+
+ private static final JAXBContext CONTEXT;
+
+ static {
+ try {
+ CONTEXT = JAXBContext.newInstance(TestSuite.class);
+ } catch (JAXBException e) {
+ throw new RuntimeException(e);
+ }
+ }
+
+ static TestSuite parse(InputStream input) {
+ try {
+ return (TestSuite) CONTEXT.createUnmarshaller().unmarshal(input);
+ } catch (JAXBException e) {
+ throw new RuntimeException("Failed to parse test XML", e);
+ }
+ }
+
+ @XmlRootElement(name = "testsuites")
+ static class TestSuite {
+ @XmlAttribute String name;
+ @XmlAttribute String classname;
+ @XmlAttribute int tests;
+ @XmlAttribute int failures;
+ @XmlAttribute int errors;
+ @XmlAttribute int skipped;
+ @XmlAttribute int disabled;
+ @XmlAttribute double time;
+
+ @XmlAttribute(name = "system-out")
+ String sysOut;
+
+ @XmlAttribute(name = "system-err")
+ String sysErr;
+
+ @XmlElement(name = "error", type = ErrorOrFailureOrSkipped.class)
+ ErrorOrFailureOrSkipped error;
+
+ @XmlElement(name = "failure", type = ErrorOrFailureOrSkipped.class)
+ ErrorOrFailureOrSkipped failure;
+
+ @XmlElement(name = "testsuite")
+ List<TestSuite> testSuites = Lists.newArrayList();
+
+ @XmlElement(name = "testdecorator")
+ List<TestSuite> testDecorators = Lists.newArrayList();
+
+ @XmlElement(name = "testcase")
+ List<TestCase> testCases = Lists.newArrayList();
+ }
+
+ static class TestCase {
+ @XmlAttribute String name;
+ @XmlAttribute String classname;
+ @XmlAttribute String status;
+ @XmlAttribute String result;
+ @XmlAttribute String time;
+
+ @XmlAttribute(name = "system-out")
+ String sysOut;
+
+ @XmlAttribute(name = "system-err")
+ String sysErr;
+
+ @XmlElement(name = "error", type = ErrorOrFailureOrSkipped.class)
+ ErrorOrFailureOrSkipped error;
+
+ @XmlElement(name = "failure", type = ErrorOrFailureOrSkipped.class)
+ ErrorOrFailureOrSkipped failure;
+
+ @XmlElement(name = "skipped", type = ErrorOrFailureOrSkipped.class)
+ ErrorOrFailureOrSkipped skipped;
+ }
+
+ static class ErrorOrFailureOrSkipped {
+ @XmlValue String content;
+ @XmlAttribute String message;
+ @XmlAttribute String type;
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/smrunner/BlazeXmlToTestEventsConverter.java b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeXmlToTestEventsConverter.java
new file mode 100644
index 0000000..82dcae8
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/smrunner/BlazeXmlToTestEventsConverter.java
@@ -0,0 +1,207 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.smrunner;
+
+import com.google.idea.blaze.base.run.smrunner.BlazeXmlSchema.ErrorOrFailureOrSkipped;
+import com.google.idea.blaze.base.run.smrunner.BlazeXmlSchema.TestCase;
+import com.google.idea.blaze.base.run.smrunner.BlazeXmlSchema.TestSuite;
+import com.google.idea.sdkcompat.smrunner.SmRunnerCompatUtils;
+import com.intellij.execution.process.ProcessOutputTypes;
+import com.intellij.execution.testframework.TestConsoleProperties;
+import com.intellij.execution.testframework.sm.runner.GeneralTestEventsProcessor;
+import com.intellij.execution.testframework.sm.runner.OutputToGeneralTestEventsConverter;
+import com.intellij.execution.testframework.sm.runner.events.TestFinishedEvent;
+import com.intellij.execution.testframework.sm.runner.events.TestIgnoredEvent;
+import com.intellij.execution.testframework.sm.runner.events.TestOutputEvent;
+import com.intellij.execution.testframework.sm.runner.events.TestStartedEvent;
+import com.intellij.execution.testframework.sm.runner.events.TestSuiteFinishedEvent;
+import com.intellij.execution.testframework.sm.runner.events.TestSuiteStartedEvent;
+import com.intellij.openapi.util.Key;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.text.ParseException;
+import javax.annotation.Nullable;
+import jetbrains.buildServer.messages.serviceMessages.ServiceMessageVisitor;
+import jetbrains.buildServer.messages.serviceMessages.TestSuiteStarted;
+
+/** Converts blaze test runner xml logs to smRunner events. */
+public class BlazeXmlToTestEventsConverter extends OutputToGeneralTestEventsConverter {
+
+ private static final ErrorOrFailureOrSkipped NO_ERROR = new ErrorOrFailureOrSkipped();
+
+ private final BlazeTestEventsHandler eventsHandler;
+
+ public BlazeXmlToTestEventsConverter(
+ String testFrameworkName,
+ TestConsoleProperties testConsoleProperties,
+ BlazeTestEventsHandler eventsHandler) {
+ super(testFrameworkName, testConsoleProperties);
+ this.eventsHandler = eventsHandler;
+ }
+
+ @Override
+ protected boolean processServiceMessages(
+ String s, Key key, ServiceMessageVisitor serviceMessageVisitor) throws ParseException {
+ return super.processServiceMessages(s, key, serviceMessageVisitor);
+ }
+
+ @Override
+ public void process(String text, Key outputType) {
+ super.process(text, outputType);
+ }
+
+ @Override
+ public void dispose() {
+ super.dispose();
+ }
+
+ @Override
+ public void flushBufferBeforeTerminating() {
+ super.flushBufferBeforeTerminating();
+ onStartTesting();
+ try (InputStream input = new FileInputStream(eventsHandler.testOutputXml)) {
+ parseXmlInput(getProcessor(), input);
+ } catch (Exception e) {
+ // ignore parsing errors -- most common cause is user cancellation, which we can't easily
+ // recognize.
+ }
+ }
+
+ private void parseXmlInput(GeneralTestEventsProcessor processor, InputStream input) {
+ TestSuite testResult = BlazeXmlSchema.parse(input);
+ processor.onTestsReporterAttached();
+ processTestSuite(processor, testResult);
+ }
+
+ private void processTestSuite(GeneralTestEventsProcessor processor, TestSuite suite) {
+ if (!hasRunChild(suite)) {
+ return;
+ }
+ // don't include the outermost 'testsuites' element.
+ boolean logSuite = suite.testSuites.isEmpty();
+ if (suite.name != null && logSuite) {
+ TestSuiteStarted suiteStarted =
+ new TestSuiteStarted(eventsHandler.suiteDisplayName(suite.name));
+ String locationUrl = eventsHandler.suiteLocationUrl(suite.name);
+ processor.onSuiteStarted(new TestSuiteStartedEvent(suiteStarted, locationUrl));
+ }
+
+ for (TestSuite child : suite.testSuites) {
+ processTestSuite(processor, child);
+ }
+ for (TestSuite decorator : suite.testDecorators) {
+ processTestSuite(processor, decorator);
+ }
+ for (TestCase test : suite.testCases) {
+ processTestCase(processor, test);
+ }
+
+ if (suite.sysOut != null) {
+ processor.onUncapturedOutput(suite.sysOut, ProcessOutputTypes.STDOUT);
+ }
+ if (suite.sysErr != null) {
+ processor.onUncapturedOutput(suite.sysErr, ProcessOutputTypes.STDERR);
+ }
+
+ if (suite.name != null && logSuite) {
+ processor.onSuiteFinished(
+ new TestSuiteFinishedEvent(eventsHandler.suiteDisplayName(suite.name)));
+ }
+ }
+
+ /**
+ * Does the test suite have at least one child which wasn't skipped? <br>
+ * This prevents spurious warnings from entirely filtered test classes.
+ */
+ private static boolean hasRunChild(TestSuite suite) {
+ for (TestSuite child : suite.testSuites) {
+ if (hasRunChild(child)) {
+ return true;
+ }
+ }
+ for (TestSuite child : suite.testDecorators) {
+ if (hasRunChild(child)) {
+ return true;
+ }
+ }
+ for (TestCase test : suite.testCases) {
+ if ("run".equals(test.status)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ private static boolean isCancelled(TestCase test) {
+ return "interrupted".equalsIgnoreCase(test.result) || "cancelled".equalsIgnoreCase(test.result);
+ }
+
+ private static boolean isIgnored(TestCase test) {
+ if (test.skipped != null) {
+ return true;
+ }
+ return "suppressed".equalsIgnoreCase(test.result)
+ || "skipped".equalsIgnoreCase(test.result)
+ || "filtered".equalsIgnoreCase(test.result);
+ }
+
+ private static boolean isFailed(TestCase test) {
+ return test.failure != null || test.error != null;
+ }
+
+ private void processTestCase(GeneralTestEventsProcessor processor, TestCase test) {
+ if (test.name == null || "notrun".equals(test.status) || isCancelled(test)) {
+ return;
+ }
+ String displayName = eventsHandler.testDisplayName(test.name);
+ String locationUrl = eventsHandler.testLocationUrl(test.name, test.classname);
+ processor.onTestStarted(new TestStartedEvent(displayName, locationUrl));
+
+ if (test.sysOut != null) {
+ processor.onTestOutput(new TestOutputEvent(displayName, test.sysOut, true));
+ }
+ if (test.sysErr != null) {
+ processor.onTestOutput(new TestOutputEvent(displayName, test.sysErr, true));
+ }
+
+ if (isIgnored(test)) {
+ ErrorOrFailureOrSkipped err = test.skipped != null ? test.skipped : NO_ERROR;
+ processor.onTestIgnored(new TestIgnoredEvent(displayName, err.message, err.content));
+ } else if (isFailed(test)) {
+ ErrorOrFailureOrSkipped err =
+ test.failure != null ? test.failure : test.error != null ? test.error : NO_ERROR;
+ processor.onTestFailure(
+ SmRunnerCompatUtils.getTestFailedEvent(
+ displayName, err.message, err.content, parseTimeMillis(test.time)));
+ }
+ processor.onTestFinished(new TestFinishedEvent(displayName, parseTimeMillis(test.time)));
+ }
+
+ private static long parseTimeMillis(@Nullable String time) {
+ if (time == null) {
+ return -1;
+ }
+ // if the number contains a decimal point, it's a value in seconds. Otherwise in milliseconds.
+ try {
+ if (time.contains(".")) {
+ return Math.round(Float.parseFloat(time) * 1000);
+ }
+ return Long.parseLong(time);
+ } catch (NumberFormatException e) {
+ return -1;
+ }
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/smrunner/SmRunnerUtils.java b/base/src/com/google/idea/blaze/base/run/smrunner/SmRunnerUtils.java
new file mode 100644
index 0000000..04715a7
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/smrunner/SmRunnerUtils.java
@@ -0,0 +1,76 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.smrunner;
+
+import com.intellij.execution.DefaultExecutionResult;
+import com.intellij.execution.Executor;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.testframework.TestConsoleProperties;
+import com.intellij.execution.testframework.actions.AbstractRerunFailedTestsAction;
+import com.intellij.execution.testframework.sm.SMTestRunnerConnectionUtil;
+import com.intellij.execution.testframework.sm.runner.SMTRunnerConsoleProperties;
+import com.intellij.execution.testframework.sm.runner.ui.SMTRunnerConsoleView;
+import com.intellij.execution.ui.ExecutionConsole;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.Disposer;
+import javax.swing.tree.TreeSelectionModel;
+
+/** Utility methods for setting up the SM runner test UI. */
+public class SmRunnerUtils {
+
+ public static final String GENERIC_SUITE_PROTOCOL = "blaze:suite";
+ public static final String GENERIC_TEST_PROTOCOL = "blaze:test";
+ public static final String TEST_NAME_PARTS_SPLITTER = "::";
+
+ public static SMTRunnerConsoleView getConsoleView(
+ Project project,
+ RunConfiguration configuration,
+ Executor executor,
+ BlazeTestEventsHandler eventsHandler) {
+ SMTRunnerConsoleProperties properties =
+ new BlazeTestConsoleProperties(configuration, executor, eventsHandler);
+ SMTRunnerConsoleView console =
+ (SMTRunnerConsoleView)
+ SMTestRunnerConnectionUtil.createConsole(eventsHandler.frameworkName, properties);
+ Disposer.register(project, console);
+ console
+ .getResultsViewer()
+ .getTreeView()
+ .getSelectionModel()
+ .setSelectionMode(TreeSelectionModel.DISCONTIGUOUS_TREE_SELECTION);
+ return console;
+ }
+
+ public static DefaultExecutionResult attachRerunFailedTestsAction(DefaultExecutionResult result) {
+ ExecutionConsole console = result.getExecutionConsole();
+ if (!(console instanceof SMTRunnerConsoleView)) {
+ return result;
+ }
+ SMTRunnerConsoleView smConsole = (SMTRunnerConsoleView) console;
+ TestConsoleProperties consoleProperties = smConsole.getProperties();
+ if (!(consoleProperties instanceof BlazeTestConsoleProperties)) {
+ return result;
+ }
+ BlazeTestConsoleProperties properties = (BlazeTestConsoleProperties) consoleProperties;
+ AbstractRerunFailedTestsAction action = properties.createRerunFailedTestsAction(smConsole);
+ if (action != null) {
+ action.init(properties);
+ action.setModelProvider(smConsole::getResultsViewer);
+ result.setRestartActions(action);
+ }
+ return result;
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/state/BlazeBinaryState.java b/base/src/com/google/idea/blaze/base/run/state/BlazeBinaryState.java
index 2ddeffc..da96aad 100644
--- a/base/src/com/google/idea/blaze/base/run/state/BlazeBinaryState.java
+++ b/base/src/com/google/idea/blaze/base/run/state/BlazeBinaryState.java
@@ -72,6 +72,11 @@
}
@Override
+ public void setComponentEnabled(boolean enabled) {
+ blazeBinaryField.setEnabled(enabled);
+ }
+
+ @Override
public void resetEditorFrom(RunConfigurationState genericState) {
BlazeBinaryState state = (BlazeBinaryState) genericState;
blazeBinaryField.setText(Strings.nullToEmpty(state.getBlazeBinary()));
diff --git a/base/src/com/google/idea/blaze/base/run/state/BlazeCommandRunConfigurationCommonState.java b/base/src/com/google/idea/blaze/base/run/state/BlazeCommandRunConfigurationCommonState.java
index ab44e47..1991ae6 100644
--- a/base/src/com/google/idea/blaze/base/run/state/BlazeCommandRunConfigurationCommonState.java
+++ b/base/src/com/google/idea/blaze/base/run/state/BlazeCommandRunConfigurationCommonState.java
@@ -17,8 +17,11 @@
import com.google.idea.blaze.base.command.BlazeCommandName;
import com.google.idea.blaze.base.command.BlazeFlags;
+import com.google.idea.blaze.base.run.state.BlazeRunOnDistributedExecutorState.RunOnExecutorStateEditor;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.intellij.execution.configurations.RuntimeConfigurationError;
import com.intellij.execution.configurations.RuntimeConfigurationException;
+import com.intellij.openapi.project.Project;
import java.io.File;
import java.util.List;
import javax.annotation.Nullable;
@@ -35,13 +38,15 @@
private final RunConfigurationFlagsState blazeFlags;
private final RunConfigurationFlagsState exeFlags;
private final BlazeBinaryState blazeBinary;
+ private final BlazeRunOnDistributedExecutorState runOnDistributedExecutor;
- public BlazeCommandRunConfigurationCommonState(String buildSystemName) {
+ public BlazeCommandRunConfigurationCommonState(BuildSystem buildSystem) {
command = new BlazeCommandState();
- blazeFlags = new RunConfigurationFlagsState(USER_BLAZE_FLAG_TAG, buildSystemName + " flags:");
+ blazeFlags = new RunConfigurationFlagsState(USER_BLAZE_FLAG_TAG, buildSystem + " flags:");
exeFlags = new RunConfigurationFlagsState(USER_EXE_FLAG_TAG, "Executable flags:");
blazeBinary = new BlazeBinaryState();
- addStates(command, blazeFlags, exeFlags, blazeBinary);
+ runOnDistributedExecutor = new BlazeRunOnDistributedExecutorState(buildSystem);
+ addStates(command, blazeFlags, exeFlags, blazeBinary, runOnDistributedExecutor);
}
@Nullable
@@ -91,6 +96,14 @@
return null;
}
+ public Boolean getRunOnDistributedExecutor() {
+ return runOnDistributedExecutor.runOnDistributedExecutor;
+ }
+
+ public void setRunOnDistributedExecutor(Boolean runOnDistributedExecutor) {
+ this.runOnDistributedExecutor.runOnDistributedExecutor = runOnDistributedExecutor;
+ }
+
public void validate(String buildSystemName) throws RuntimeConfigurationException {
if (getCommand() == null) {
throw new RuntimeConfigurationError("You must specify a command.");
@@ -100,4 +113,32 @@
throw new RuntimeConfigurationError(buildSystemName + " binary does not exist");
}
}
+
+ @Override
+ public RunConfigurationStateEditor getEditor(Project project) {
+ return new RunConfigurationCompositeStateEditor(project, getStates()) {
+
+ @Nullable
+ private final RunOnExecutorStateEditor runOnExecutorEditor =
+ (RunOnExecutorStateEditor)
+ editors
+ .stream()
+ .filter(editor -> editor instanceof RunOnExecutorStateEditor)
+ .findFirst()
+ .orElse(null);
+
+ @Override
+ public void applyEditorTo(RunConfigurationState genericState) {
+ BlazeCommandRunConfigurationCommonState state =
+ (BlazeCommandRunConfigurationCommonState) genericState;
+ super.applyEditorTo(genericState);
+
+ // this editor needs to update based on state provided by other children.
+ if (runOnExecutorEditor != null) {
+ boolean isTest = BlazeCommandName.TEST.equals(state.getCommand());
+ runOnExecutorEditor.updateVisibility(isTest);
+ }
+ }
+ };
+ }
}
diff --git a/base/src/com/google/idea/blaze/base/run/state/BlazeCommandState.java b/base/src/com/google/idea/blaze/base/run/state/BlazeCommandState.java
index 491acb7..221fe10 100644
--- a/base/src/com/google/idea/blaze/base/run/state/BlazeCommandState.java
+++ b/base/src/com/google/idea/blaze/base/run/state/BlazeCommandState.java
@@ -79,6 +79,11 @@
}
@Override
+ public void setComponentEnabled(boolean enabled) {
+ commandCombo.setEnabled(enabled);
+ }
+
+ @Override
public void resetEditorFrom(RunConfigurationState genericState) {
BlazeCommandState state = (BlazeCommandState) genericState;
commandCombo.setSelectedItem(state.getCommand());
diff --git a/base/src/com/google/idea/blaze/base/run/state/BlazeRunOnDistributedExecutorState.java b/base/src/com/google/idea/blaze/base/run/state/BlazeRunOnDistributedExecutorState.java
new file mode 100644
index 0000000..b251d3f
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/run/state/BlazeRunOnDistributedExecutorState.java
@@ -0,0 +1,127 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.state;
+
+import com.google.idea.blaze.base.run.DistributedExecutorSupport;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
+import com.google.idea.blaze.base.ui.UiUtil;
+import com.intellij.icons.AllIcons;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.InvalidDataException;
+import com.intellij.openapi.util.WriteExternalException;
+import com.intellij.ui.components.JBCheckBox;
+import javax.annotation.Nullable;
+import javax.swing.JComponent;
+import javax.swing.JLabel;
+import org.jdom.Element;
+
+/**
+ * Provides an option to run blaze/bazel on a distributed executor, if available, rather than
+ * locally.
+ */
+public class BlazeRunOnDistributedExecutorState implements RunConfigurationState {
+
+ private static final String RUN_ON_DISTRIBUTED_EXECUTOR_ATTR =
+ "blaze-run-on-distributed-executor";
+
+ @Nullable private final DistributedExecutorSupport executorInfo;
+
+ public Boolean runOnDistributedExecutor = null;
+
+ BlazeRunOnDistributedExecutorState(BuildSystem buildSystem) {
+ this.executorInfo = DistributedExecutorSupport.getAvailableExecutor(buildSystem);
+ }
+
+ @Override
+ public void readExternal(Element element) throws InvalidDataException {
+ String string = element.getAttributeValue(RUN_ON_DISTRIBUTED_EXECUTOR_ATTR);
+ if (string != null) {
+ runOnDistributedExecutor = Boolean.parseBoolean(string);
+ }
+ }
+
+ @Override
+ public void writeExternal(Element element) throws WriteExternalException {
+ if (executorInfo != null && runOnDistributedExecutor != null) {
+ element.setAttribute(
+ RUN_ON_DISTRIBUTED_EXECUTOR_ATTR, Boolean.toString(runOnDistributedExecutor));
+ } else {
+ element.removeAttribute(RUN_ON_DISTRIBUTED_EXECUTOR_ATTR);
+ }
+ }
+
+ @Override
+ public RunOnExecutorStateEditor getEditor(Project project) {
+ return new RunOnExecutorStateEditor();
+ }
+
+ /** Editor for {@link BlazeRunOnDistributedExecutorState} */
+ class RunOnExecutorStateEditor implements RunConfigurationStateEditor {
+
+ private final JBCheckBox checkBox =
+ new JBCheckBox("Run on " + (executorInfo != null ? executorInfo.executorName() : null));
+ private final JLabel warning =
+ new JLabel(
+ "Warning: test UI integration is not available when running on distributed "
+ + "executor");
+
+ private boolean componentVisible = executorInfo != null;
+ private boolean isTest = false;
+
+ private RunOnExecutorStateEditor() {
+ warning.setIcon(AllIcons.RunConfigurations.ConfigurationWarning);
+ checkBox.addItemListener(e -> setVisibility());
+ setVisibility();
+ }
+
+ @Override
+ public void resetEditorFrom(RunConfigurationState genericState) {
+ BlazeRunOnDistributedExecutorState state = (BlazeRunOnDistributedExecutorState) genericState;
+ if (state.runOnDistributedExecutor != null) {
+ checkBox.setSelected(state.runOnDistributedExecutor);
+ }
+ }
+
+ @Override
+ public void applyEditorTo(RunConfigurationState genericState) {
+ BlazeRunOnDistributedExecutorState state = (BlazeRunOnDistributedExecutorState) genericState;
+ if (checkBox.isVisible()) {
+ state.runOnDistributedExecutor = checkBox.isSelected();
+ }
+ }
+
+ @Override
+ public JComponent createComponent() {
+ return UiUtil.createBox(checkBox, warning);
+ }
+
+ @Override
+ public void setComponentEnabled(boolean enabled) {
+ checkBox.setEnabled(enabled);
+ }
+
+ void updateVisibility(boolean isTest) {
+ this.componentVisible = executorInfo != null;
+ this.isTest = isTest;
+ setVisibility();
+ }
+
+ private void setVisibility() {
+ warning.setVisible(componentVisible && isTest && checkBox.isSelected());
+ checkBox.setVisible(componentVisible);
+ }
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/run/state/RunConfigurationCompositeState.java b/base/src/com/google/idea/blaze/base/run/state/RunConfigurationCompositeState.java
index 077e02d..a317232 100644
--- a/base/src/com/google/idea/blaze/base/run/state/RunConfigurationCompositeState.java
+++ b/base/src/com/google/idea/blaze/base/run/state/RunConfigurationCompositeState.java
@@ -15,6 +15,7 @@
*/
package com.google.idea.blaze.base.run.state;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
import com.google.idea.blaze.base.ui.UiUtil;
import com.intellij.openapi.project.Project;
@@ -30,10 +31,6 @@
public class RunConfigurationCompositeState implements RunConfigurationState {
private final List<RunConfigurationState> states;
- public RunConfigurationCompositeState(List<RunConfigurationState> states) {
- this.states = states;
- }
-
protected RunConfigurationCompositeState() {
this.states = Lists.newArrayList();
}
@@ -42,6 +39,10 @@
Collections.addAll(this.states, states);
}
+ protected ImmutableList<RunConfigurationState> getStates() {
+ return ImmutableList.copyOf(states);
+ }
+
@Override
public final void readExternal(Element element) throws InvalidDataException {
for (RunConfigurationState state : states) {
@@ -60,11 +61,11 @@
/** @return A {@link RunConfigurationStateEditor} for this state. */
@Override
- public final RunConfigurationStateEditor getEditor(Project project) {
+ public RunConfigurationStateEditor getEditor(Project project) {
return new RunConfigurationCompositeStateEditor(project, states);
}
- private static class RunConfigurationCompositeStateEditor implements RunConfigurationStateEditor {
+ static class RunConfigurationCompositeStateEditor implements RunConfigurationStateEditor {
List<RunConfigurationStateEditor> editors;
public RunConfigurationCompositeStateEditor(
@@ -96,5 +97,10 @@
.map(RunConfigurationStateEditor::createComponent)
.collect(Collectors.toList()));
}
+
+ @Override
+ public void setComponentEnabled(boolean enabled) {
+ editors.forEach(editor -> editor.setComponentEnabled(enabled));
+ }
}
}
diff --git a/base/src/com/google/idea/blaze/base/run/state/RunConfigurationFlagsState.java b/base/src/com/google/idea/blaze/base/run/state/RunConfigurationFlagsState.java
index c0edaa4..87d306c 100644
--- a/base/src/com/google/idea/blaze/base/run/state/RunConfigurationFlagsState.java
+++ b/base/src/com/google/idea/blaze/base/run/state/RunConfigurationFlagsState.java
@@ -19,6 +19,7 @@
import com.google.common.collect.ImmutableList;
import com.google.idea.blaze.base.ui.UiUtil;
import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.text.StringUtil;
import com.intellij.util.execution.ParametersListUtil;
import java.util.List;
import javax.swing.JComponent;
@@ -85,27 +86,38 @@
this.fieldLabel = fieldLabel;
}
+ /** Identical to {@link ParametersListUtil#join}, except args are newline-delimited. */
private static String makeFlagString(List<String> flags) {
- StringBuilder flagString = new StringBuilder();
+ StringBuilder builder = new StringBuilder();
for (String flag : flags) {
- if (flagString.length() > 0) {
- flagString.append('\n');
+ if (builder.length() > 0) {
+ builder.append('\n');
}
- if (flag.isEmpty() || flag.contains(" ") || flag.contains("|")) {
- flagString.append('"');
- flagString.append(flag);
- flagString.append('"');
- } else {
- flagString.append(flag);
- }
+ builder.append(encode(flag));
}
- return flagString.toString();
+ return builder.toString();
+ }
+
+ private static String encode(String flag) {
+ StringBuilder builder = new StringBuilder();
+ builder.append(flag);
+ StringUtil.escapeQuotes(builder);
+ if (builder.length() == 0
+ || StringUtil.indexOf(builder, ' ') >= 0
+ || StringUtil.indexOf(builder, '|') >= 0) {
+ StringUtil.quote(builder);
+ }
+ return builder.toString();
+ }
+
+ @Override
+ public void setComponentEnabled(boolean enabled) {
+ flagsField.setEnabled(enabled);
}
@Override
public void resetEditorFrom(RunConfigurationState genericState) {
RunConfigurationFlagsState state = (RunConfigurationFlagsState) genericState;
- // Normally we could just use ParametersListUtils.join, but that will only space-delimit args.
flagsField.setText(makeFlagString(state.getFlags()));
}
diff --git a/base/src/com/google/idea/blaze/base/run/state/RunConfigurationStateEditor.java b/base/src/com/google/idea/blaze/base/run/state/RunConfigurationStateEditor.java
index b04020e..3a905fc 100644
--- a/base/src/com/google/idea/blaze/base/run/state/RunConfigurationStateEditor.java
+++ b/base/src/com/google/idea/blaze/base/run/state/RunConfigurationStateEditor.java
@@ -28,4 +28,6 @@
/** @return A component to display for the editor. */
JComponent createComponent();
+
+ void setComponentEnabled(boolean enabled);
}
diff --git a/base/src/com/google/idea/blaze/base/run/testmap/TestTargetFilterImpl.java b/base/src/com/google/idea/blaze/base/run/testmap/TestTargetFilterImpl.java
index 0b336f4..99d490f 100644
--- a/base/src/com/google/idea/blaze/base/run/testmap/TestTargetFilterImpl.java
+++ b/base/src/com/google/idea/blaze/base/run/testmap/TestTargetFilterImpl.java
@@ -134,7 +134,8 @@
Kind.JAVA_TEST,
Kind.GWT_TEST,
Kind.CC_TEST,
- Kind.PY_TEST);
+ Kind.PY_TEST,
+ Kind.GO_TEST);
}
}
diff --git a/base/src/com/google/idea/blaze/base/settings/ui/EditProjectViewAction.java b/base/src/com/google/idea/blaze/base/settings/ui/EditProjectViewAction.java
index b2e86be..926483b 100644
--- a/base/src/com/google/idea/blaze/base/settings/ui/EditProjectViewAction.java
+++ b/base/src/com/google/idea/blaze/base/settings/ui/EditProjectViewAction.java
@@ -15,7 +15,7 @@
*/
package com.google.idea.blaze.base.settings.ui;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.projectview.ProjectViewManager;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.intellij.openapi.actionSystem.AnActionEvent;
@@ -27,14 +27,10 @@
import java.io.File;
/** Opens all the user's project views. */
-public class EditProjectViewAction extends BlazeAction {
+public class EditProjectViewAction extends BlazeProjectAction {
@Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- if (project == null) {
- return;
- }
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
if (projectViewSet == null) {
return;
diff --git a/base/src/com/google/idea/blaze/base/sync/BlazeSyncManager.java b/base/src/com/google/idea/blaze/base/sync/BlazeSyncManager.java
index db3cba2..c1c36b7 100644
--- a/base/src/com/google/idea/blaze/base/sync/BlazeSyncManager.java
+++ b/base/src/com/google/idea/blaze/base/sync/BlazeSyncManager.java
@@ -16,29 +16,31 @@
package com.google.idea.blaze.base.sync;
import com.google.idea.blaze.base.async.executor.BlazeExecutor;
+import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.settings.BlazeImportSettings;
import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
+import com.google.idea.blaze.base.settings.BlazeUserSettings;
import com.intellij.openapi.components.ServiceManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.startup.StartupManager;
-import org.jetbrains.annotations.NotNull;
+import java.util.List;
/** Manages syncing and its listeners. */
public class BlazeSyncManager {
- @NotNull private final Project project;
+ private final Project project;
- public BlazeSyncManager(@NotNull Project project) {
+ public BlazeSyncManager(Project project) {
this.project = project;
}
- public static BlazeSyncManager getInstance(@NotNull Project project) {
+ public static BlazeSyncManager getInstance(Project project) {
return ServiceManager.getService(project, BlazeSyncManager.class);
}
/** Requests a project sync with Blaze. */
- public void requestProjectSync(@NotNull final BlazeSyncParams syncParams) {
+ public void requestProjectSync(final BlazeSyncParams syncParams) {
StartupManager.getInstance(project)
.runWhenProjectIsInitialized(
new Runnable() {
@@ -59,4 +61,38 @@
}
});
}
+
+ public void fullProjectSync() {
+ BlazeSyncParams syncParams =
+ new BlazeSyncParams.Builder("Full Sync", BlazeSyncParams.SyncMode.FULL)
+ .addProjectViewTargets(true)
+ .addWorkingSet(BlazeUserSettings.getInstance().getExpandSyncToWorkingSet())
+ .build();
+ requestProjectSync(syncParams);
+ }
+
+ public void incrementalProjectSync() {
+ BlazeSyncParams syncParams =
+ new BlazeSyncParams.Builder("Sync", BlazeSyncParams.SyncMode.INCREMENTAL)
+ .addProjectViewTargets(true)
+ .addWorkingSet(BlazeUserSettings.getInstance().getExpandSyncToWorkingSet())
+ .build();
+ requestProjectSync(syncParams);
+ }
+
+ public void partialSync(List<TargetExpression> targetExpressions) {
+ BlazeSyncParams syncParams =
+ new BlazeSyncParams.Builder("Partial Sync", BlazeSyncParams.SyncMode.PARTIAL)
+ .addTargetExpressions(targetExpressions)
+ .build();
+ requestProjectSync(syncParams);
+ }
+
+ public void workingSetSync() {
+ BlazeSyncParams syncParams =
+ new BlazeSyncParams.Builder("Sync Working Set", BlazeSyncParams.SyncMode.PARTIAL)
+ .addWorkingSet(true)
+ .build();
+ requestProjectSync(syncParams);
+ }
}
diff --git a/base/src/com/google/idea/blaze/base/sync/BlazeSyncParams.java b/base/src/com/google/idea/blaze/base/sync/BlazeSyncParams.java
index 2ee84c7..22fba9c 100644
--- a/base/src/com/google/idea/blaze/base/sync/BlazeSyncParams.java
+++ b/base/src/com/google/idea/blaze/base/sync/BlazeSyncParams.java
@@ -27,7 +27,7 @@
/** The kind of sync. */
public enum SyncMode {
/** Happens on startup, restores in-memory state */
- RESTORE_EPHEMERAL_STATE,
+ STARTUP,
/** Partial / working set sync */
PARTIAL,
/** This is the standard incremental sync */
diff --git a/base/src/com/google/idea/blaze/base/sync/BlazeSyncPlugin.java b/base/src/com/google/idea/blaze/base/sync/BlazeSyncPlugin.java
index 0b55343..aa429f3 100644
--- a/base/src/com/google/idea/blaze/base/sync/BlazeSyncPlugin.java
+++ b/base/src/com/google/idea/blaze/base/sync/BlazeSyncPlugin.java
@@ -19,6 +19,7 @@
import com.google.common.collect.ImmutableSet;
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.LanguageClass;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
@@ -119,6 +120,7 @@
Project project,
BlazeContext context,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
BlazeProjectData blazeProjectData);
@Nullable
@@ -136,6 +138,19 @@
Module workspaceModule,
ModifiableRootModel workspaceModifiableModel);
+ /**
+ * Updates in-memory state that isn't serialized by IntelliJ.
+ *
+ * <p>Called on sync and on startup, after updateProjectStructure. May not do any write actions.
+ */
+ void updateInMemoryState(
+ Project project,
+ BlazeContext context,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeProjectData blazeProjectData,
+ Module workspaceModule);
+
/** Validates the project. */
boolean validate(Project project, BlazeContext context, BlazeProjectData blazeProjectData);
@@ -203,6 +218,7 @@
Project project,
BlazeContext context,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
BlazeProjectData blazeProjectData) {}
@Nullable
@@ -224,6 +240,15 @@
ModifiableRootModel workspaceModifiableModel) {}
@Override
+ public void updateInMemoryState(
+ Project project,
+ BlazeContext context,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeProjectData blazeProjectData,
+ Module workspaceModule) {}
+
+ @Override
public boolean validate(
Project project, BlazeContext context, BlazeProjectData blazeProjectData) {
return true;
diff --git a/base/src/com/google/idea/blaze/base/sync/BlazeSyncStartupActivity.java b/base/src/com/google/idea/blaze/base/sync/BlazeSyncStartupActivity.java
index 5b6a8ee..0fe7dac 100644
--- a/base/src/com/google/idea/blaze/base/sync/BlazeSyncStartupActivity.java
+++ b/base/src/com/google/idea/blaze/base/sync/BlazeSyncStartupActivity.java
@@ -43,8 +43,7 @@
.addWorkingSet(BlazeUserSettings.getInstance().getExpandSyncToWorkingSet())
.build();
}
- return new BlazeSyncParams.Builder(
- "Sync Project", BlazeSyncParams.SyncMode.RESTORE_EPHEMERAL_STATE)
+ return new BlazeSyncParams.Builder("Sync Project", BlazeSyncParams.SyncMode.STARTUP)
.addProjectViewTargets(true)
.addWorkingSet(BlazeUserSettings.getInstance().getExpandSyncToWorkingSet())
.build();
diff --git a/base/src/com/google/idea/blaze/base/sync/BlazeSyncTask.java b/base/src/com/google/idea/blaze/base/sync/BlazeSyncTask.java
index 3d4e3ec..1fb59c9 100644
--- a/base/src/com/google/idea/blaze/base/sync/BlazeSyncTask.java
+++ b/base/src/com/google/idea/blaze/base/sync/BlazeSyncTask.java
@@ -24,7 +24,6 @@
import com.google.common.collect.Sets;
import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.ListeningExecutorService;
-import com.google.idea.blaze.base.async.AsyncUtil;
import com.google.idea.blaze.base.async.FutureUtil;
import com.google.idea.blaze.base.async.executor.BlazeExecutor;
import com.google.idea.blaze.base.command.info.BlazeInfo;
@@ -32,10 +31,13 @@
import com.google.idea.blaze.base.filecache.FileCaches;
import com.google.idea.blaze.base.ideinfo.TargetKey;
import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.io.FileAttributeProvider;
import com.google.idea.blaze.base.metrics.Action;
import com.google.idea.blaze.base.model.BlazeLibrary;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.SyncState;
+import com.google.idea.blaze.base.model.SyncState.Builder;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.model.primitives.WorkspacePath;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
@@ -66,6 +68,7 @@
import com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface;
import com.google.idea.blaze.base.sync.aspects.BlazeIdeInterface.BuildResult;
import com.google.idea.blaze.base.sync.data.BlazeDataStorage;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
import com.google.idea.blaze.base.sync.data.BlazeProjectDataManagerImpl;
import com.google.idea.blaze.base.sync.libraries.BlazeLibraryCollector;
import com.google.idea.blaze.base.sync.libraries.LibraryEditor;
@@ -84,9 +87,11 @@
import com.google.idea.blaze.base.targetmaps.ReverseDependencyMap;
import com.google.idea.blaze.base.util.SaveUtil;
import com.google.idea.blaze.base.vcs.BlazeVcsHandler;
+import com.google.idea.sdkcompat.transactions.Transactions;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleManager;
import com.intellij.openapi.module.ModuleType;
import com.intellij.openapi.progress.ProgressIndicator;
import com.intellij.openapi.progress.Progressive;
@@ -173,7 +178,18 @@
}
onSyncStart(project, context, syncMode);
- syncResult = doSyncProject(context, syncMode, oldBlazeProjectData);
+ if (syncMode != SyncMode.STARTUP) {
+ syncResult = doSyncProject(context, syncMode, oldBlazeProjectData);
+ } else {
+ syncResult = SyncResult.SUCCESS;
+ }
+ if (syncResult.successful()) {
+ ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+ updateInMemoryState(project, context, projectViewSet, blazeProjectData);
+ onSyncComplete(project, context, projectViewSet, blazeProjectData, syncMode, syncResult);
+ }
} catch (AssertionError | Exception e) {
LOG.error(e);
IssueOutput.error("Internal error: " + e.getMessage()).submit(context);
@@ -188,13 +204,13 @@
BlazeContext context, SyncMode syncMode, @Nullable BlazeProjectData oldBlazeProjectData) {
this.syncStartTime = System.currentTimeMillis();
- BlazeVcsHandler vcsHandler = null;
- for (BlazeVcsHandler candidate : BlazeVcsHandler.EP_NAME.getExtensions()) {
- if (candidate.handlesProject(importSettings.getBuildSystem(), workspaceRoot)) {
- vcsHandler = candidate;
- break;
- }
+ if (!FileAttributeProvider.getInstance().exists(workspaceRoot.directory())) {
+ IssueOutput.error(String.format("Workspace '%s' doesn't exist.", workspaceRoot.directory()))
+ .submit(context);
+ return SyncResult.FAILURE;
}
+
+ BlazeVcsHandler vcsHandler = BlazeVcsHandler.vcsHandlerForProject(project);
if (vcsHandler == null) {
IssueOutput.error("Could not find a VCS handler").submit(context);
return SyncResult.FAILURE;
@@ -222,6 +238,8 @@
}
BlazeRoots blazeRoots =
BlazeRoots.build(importSettings.getBuildSystem(), workspaceRoot, blazeInfo);
+ BlazeVersionData blazeVersionData =
+ BlazeVersionData.build(importSettings.getBuildSystem(), workspaceRoot, blazeInfo);
WorkspacePathResolverAndProjectView workspacePathResolverAndProjectView =
computeWorkspacePathResolverAndProjectView(context, blazeRoots, vcsHandler, executor);
@@ -245,7 +263,7 @@
}
if (!ProjectViewVerifier.verifyProjectView(
- context, workspaceRoot, projectViewSet, workspaceLanguageSettings)) {
+ context, workspacePathResolver, projectViewSet, workspaceLanguageSettings)) {
return SyncResult.FAILURE;
}
@@ -269,120 +287,112 @@
printWorkingSet(context, workingSet);
}
- BuildResult ideInfoResult = BuildResult.SUCCESS;
- BuildResult ideResolveResult = BuildResult.SUCCESS;
- if (syncMode != SyncMode.RESTORE_EPHEMERAL_STATE || oldBlazeProjectData == null) {
- SyncState.Builder syncStateBuilder = new SyncState.Builder();
- SyncState previousSyncState =
- oldBlazeProjectData != null ? oldBlazeProjectData.syncState : null;
+ SyncState.Builder syncStateBuilder = new SyncState.Builder();
+ SyncState previousSyncState =
+ oldBlazeProjectData != null ? oldBlazeProjectData.syncState : null;
- List<TargetExpression> targets = Lists.newArrayList();
- if (syncParams.addProjectViewTargets || oldBlazeProjectData == null) {
- Collection<TargetExpression> projectViewTargets =
- projectViewSet.listItems(TargetSection.KEY);
- if (!projectViewTargets.isEmpty()) {
- targets.addAll(projectViewTargets);
- printTargets(context, "project view", projectViewTargets);
- }
+ List<TargetExpression> targets = Lists.newArrayList();
+ if (syncParams.addProjectViewTargets || oldBlazeProjectData == null) {
+ Collection<TargetExpression> projectViewTargets = projectViewSet.listItems(TargetSection.KEY);
+ if (!projectViewTargets.isEmpty()) {
+ targets.addAll(projectViewTargets);
+ printTargets(context, "project view", projectViewTargets);
}
- if (syncParams.addWorkingSet && workingSet != null) {
- Collection<? extends TargetExpression> workingSetTargets =
- getWorkingSetTargets(projectViewSet, workingSet);
- if (!workingSetTargets.isEmpty()) {
- targets.addAll(workingSetTargets);
- printTargets(context, "working set", workingSetTargets);
- }
- }
- if (!syncParams.targetExpressions.isEmpty()) {
- targets.addAll(syncParams.targetExpressions);
- printTargets(context, syncParams.title, syncParams.targetExpressions);
- }
-
- boolean mergeWithOldState = !syncParams.addProjectViewTargets;
- BlazeIdeInterface.IdeResult ideQueryResult =
- getIdeQueryResult(
- project,
- context,
- projectViewSet,
- targets,
- workspaceLanguageSettings,
- artifactLocationDecoder,
- syncStateBuilder,
- previousSyncState,
- mergeWithOldState);
- if (context.isCancelled()) {
- return SyncResult.CANCELLED;
- }
- if (ideQueryResult.targetMap == null
- || ideQueryResult.buildResult == BuildResult.FATAL_ERROR) {
- context.setHasError();
- return SyncResult.FAILURE;
- }
-
- TargetMap targetMap = ideQueryResult.targetMap;
- ideInfoResult = ideQueryResult.buildResult;
-
- ListenableFuture<ImmutableMultimap<TargetKey, TargetKey>> reverseDependenciesFuture =
- BlazeExecutor.getInstance().submit(() -> ReverseDependencyMap.createRdepsMap(targetMap));
-
- ideResolveResult =
- resolveIdeArtifacts(project, context, workspaceRoot, projectViewSet, targets);
- if (ideResolveResult == BuildResult.FATAL_ERROR) {
- context.setHasError();
- return SyncResult.FAILURE;
- }
- if (context.isCancelled()) {
- return SyncResult.CANCELLED;
- }
-
- Scope.push(
- context,
- (childContext) -> {
- childContext.push(new TimingScope("UpdateSyncState"));
- for (BlazeSyncPlugin syncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) {
- syncPlugin.updateSyncState(
- project,
- childContext,
- workspaceRoot,
- projectViewSet,
- workspaceLanguageSettings,
- blazeRoots,
- workingSet,
- workspacePathResolver,
- artifactLocationDecoder,
- targetMap,
- syncStateBuilder,
- previousSyncState);
- }
- });
-
- ImmutableMultimap<TargetKey, TargetKey> reverseDependencies =
- FutureUtil.waitForFuture(context, reverseDependenciesFuture)
- .timed("ReverseDependencies")
- .onError("Failed to compute reverse dependency map")
- .run()
- .result();
- if (reverseDependencies == null) {
- return SyncResult.FAILURE;
- }
-
- newBlazeProjectData =
- new BlazeProjectData(
- syncStartTime,
- targetMap,
- blazeInfo,
- blazeRoots,
- workingSet,
- workspacePathResolver,
- artifactLocationDecoder,
- workspaceLanguageSettings,
- syncStateBuilder.build(),
- reverseDependencies,
- vcsHandler.getVcsName());
- } else {
- // Restore project based on old blaze project data
- newBlazeProjectData = oldBlazeProjectData;
}
+ if (syncParams.addWorkingSet && workingSet != null) {
+ Collection<? extends TargetExpression> workingSetTargets =
+ getWorkingSetTargets(projectViewSet, workingSet);
+ if (!workingSetTargets.isEmpty()) {
+ targets.addAll(workingSetTargets);
+ printTargets(context, "working set", workingSetTargets);
+ }
+ }
+ if (!syncParams.targetExpressions.isEmpty()) {
+ targets.addAll(syncParams.targetExpressions);
+ printTargets(context, syncParams.title, syncParams.targetExpressions);
+ }
+
+ boolean mergeWithOldState = !syncParams.addProjectViewTargets;
+ BlazeIdeInterface.IdeResult ideQueryResult =
+ getIdeQueryResult(
+ project,
+ context,
+ projectViewSet,
+ blazeVersionData,
+ targets,
+ workspaceLanguageSettings,
+ artifactLocationDecoder,
+ syncStateBuilder,
+ previousSyncState,
+ mergeWithOldState);
+ if (context.isCancelled()) {
+ return SyncResult.CANCELLED;
+ }
+ if (ideQueryResult.targetMap == null || ideQueryResult.buildResult == BuildResult.FATAL_ERROR) {
+ context.setHasError();
+ return SyncResult.FAILURE;
+ }
+
+ TargetMap targetMap = ideQueryResult.targetMap;
+ BuildResult ideInfoResult = ideQueryResult.buildResult;
+
+ ListenableFuture<ImmutableMultimap<TargetKey, TargetKey>> reverseDependenciesFuture =
+ BlazeExecutor.getInstance().submit(() -> ReverseDependencyMap.createRdepsMap(targetMap));
+
+ BuildResult ideResolveResult =
+ resolveIdeArtifacts(
+ project, context, workspaceRoot, projectViewSet, blazeVersionData, targets);
+ if (ideResolveResult == BuildResult.FATAL_ERROR) {
+ context.setHasError();
+ return SyncResult.FAILURE;
+ }
+ if (context.isCancelled()) {
+ return SyncResult.CANCELLED;
+ }
+
+ Scope.push(
+ context,
+ (childContext) -> {
+ childContext.push(new TimingScope("UpdateSyncState"));
+ for (BlazeSyncPlugin syncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) {
+ syncPlugin.updateSyncState(
+ project,
+ childContext,
+ workspaceRoot,
+ projectViewSet,
+ workspaceLanguageSettings,
+ blazeRoots,
+ workingSet,
+ workspacePathResolver,
+ artifactLocationDecoder,
+ targetMap,
+ syncStateBuilder,
+ previousSyncState);
+ }
+ });
+
+ ImmutableMultimap<TargetKey, TargetKey> reverseDependencies =
+ FutureUtil.waitForFuture(context, reverseDependenciesFuture)
+ .timed("ReverseDependencies")
+ .onError("Failed to compute reverse dependency map")
+ .run()
+ .result();
+ if (reverseDependencies == null) {
+ return SyncResult.FAILURE;
+ }
+
+ newBlazeProjectData =
+ new BlazeProjectData(
+ syncStartTime,
+ targetMap,
+ blazeInfo,
+ blazeRoots,
+ blazeVersionData,
+ workspacePathResolver,
+ artifactLocationDecoder,
+ workspaceLanguageSettings,
+ syncStateBuilder.build(),
+ reverseDependencies);
FileCaches.onSync(project, context, projectViewSet, newBlazeProjectData, syncMode);
ListenableFuture<?> prefetch =
@@ -394,7 +404,13 @@
.run();
boolean success =
- updateProject(project, context, projectViewSet, oldBlazeProjectData, newBlazeProjectData);
+ updateProject(
+ project,
+ context,
+ projectViewSet,
+ blazeVersionData,
+ oldBlazeProjectData,
+ newBlazeProjectData);
if (!success) {
return SyncResult.FAILURE;
}
@@ -417,7 +433,6 @@
syncResult = SyncResult.PARTIAL_SUCCESS;
}
- onSyncComplete(project, context, projectViewSet, newBlazeProjectData, syncMode, syncResult);
return syncResult;
}
@@ -555,10 +570,11 @@
Project project,
BlazeContext parentContext,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
List<TargetExpression> targets,
WorkspaceLanguageSettings workspaceLanguageSettings,
ArtifactLocationDecoder artifactLocationDecoder,
- SyncState.Builder syncStateBuilder,
+ Builder syncStateBuilder,
@Nullable SyncState previousSyncState,
boolean mergeWithOldState) {
@@ -575,6 +591,7 @@
context,
workspaceRoot,
projectViewSet,
+ blazeVersionData,
targets,
workspaceLanguageSettings,
artifactLocationDecoder,
@@ -589,6 +606,7 @@
BlazeContext parentContext,
WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
List<TargetExpression> targetExpressions) {
return Scope.push(
parentContext,
@@ -606,7 +624,7 @@
}
BlazeIdeInterface blazeIdeInterface = BlazeIdeInterface.getInstance();
return blazeIdeInterface.resolveIdeArtifacts(
- project, context, workspaceRoot, projectViewSet, targetExpressions);
+ project, context, workspaceRoot, projectViewSet, blazeVersionData, targetExpressions);
});
}
@@ -614,6 +632,7 @@
Project project,
BlazeContext parentContext,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
@Nullable BlazeProjectData oldBlazeProjectData,
BlazeProjectData newBlazeProjectData) {
return Scope.push(
@@ -625,19 +644,29 @@
context.output(new StatusOutput("Committing project structure..."));
try {
- AsyncUtil.executeProjectChangeAction(
- () ->
- ProjectRootManagerEx.getInstanceEx(this.project)
- .mergeRootsChangesDuring(
- () -> {
- updateProjectSdk(context, projectViewSet, newBlazeProjectData);
- updateProjectStructure(
- context,
- importSettings,
- projectViewSet,
- newBlazeProjectData,
- oldBlazeProjectData);
- }));
+ Transactions.submitTransactionAndWait(
+ () -> {
+ ApplicationManager.getApplication()
+ .runWriteAction(
+ (Runnable)
+ () -> {
+ ProjectRootManagerEx.getInstanceEx(this.project)
+ .mergeRootsChangesDuring(
+ () -> {
+ updateProjectSdk(
+ context,
+ projectViewSet,
+ blazeVersionData,
+ newBlazeProjectData);
+ updateProjectStructure(
+ context,
+ importSettings,
+ projectViewSet,
+ newBlazeProjectData,
+ oldBlazeProjectData);
+ });
+ });
+ });
} catch (Throwable t) {
IssueOutput.error("Internal error. Error: " + t).submit(context);
LOG.error(t);
@@ -651,9 +680,13 @@
}
private void updateProjectSdk(
- BlazeContext context, ProjectViewSet projectViewSet, BlazeProjectData newBlazeProjectData) {
+ BlazeContext context,
+ ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
+ BlazeProjectData newBlazeProjectData) {
for (BlazeSyncPlugin syncPlugin : BlazeSyncPlugin.EP_NAME.getExtensions()) {
- syncPlugin.updateProjectSdk(project, context, projectViewSet, newBlazeProjectData);
+ syncPlugin.updateProjectSdk(
+ project, context, projectViewSet, blazeVersionData, newBlazeProjectData);
}
}
@@ -716,6 +749,36 @@
moduleEditor.commitWithGc(context);
}
+ private void updateInMemoryState(
+ Project project,
+ BlazeContext parentContext,
+ ProjectViewSet projectViewSet,
+ BlazeProjectData blazeProjectData) {
+ Scope.push(
+ parentContext,
+ context -> {
+ context.push(new TimingScope("UpdateInMemoryState"));
+ context.output(new StatusOutput("Updating in-memory state..."));
+ ApplicationManager.getApplication()
+ .runReadAction(
+ () -> {
+ Module workspaceModule =
+ ModuleManager.getInstance(project)
+ .findModuleByName(BlazeDataStorage.WORKSPACE_MODULE_NAME);
+ for (BlazeSyncPlugin blazeSyncPlugin :
+ BlazeSyncPlugin.EP_NAME.getExtensions()) {
+ blazeSyncPlugin.updateInMemoryState(
+ project,
+ context,
+ workspaceRoot,
+ projectViewSet,
+ blazeProjectData,
+ workspaceModule);
+ }
+ });
+ });
+ }
+
/**
* Creates a module that includes the user's data directory.
*
diff --git a/base/src/com/google/idea/blaze/base/sync/SyncListener.java b/base/src/com/google/idea/blaze/base/sync/SyncListener.java
index a3512cb..7a0cf03 100644
--- a/base/src/com/google/idea/blaze/base/sync/SyncListener.java
+++ b/base/src/com/google/idea/blaze/base/sync/SyncListener.java
@@ -31,13 +31,23 @@
/** Result of the sync operation */
enum SyncResult {
/** Full success */
- SUCCESS,
+ SUCCESS(true),
/** The user has errors in their BUILD files or compilation errors */
- PARTIAL_SUCCESS,
+ PARTIAL_SUCCESS(true),
/** The user cancelled */
- CANCELLED,
+ CANCELLED(false),
/** Failure -- sync could not complete */
- FAILURE,
+ FAILURE(false);
+
+ private final boolean success;
+
+ SyncResult(boolean success) {
+ this.success = success;
+ }
+
+ public boolean successful() {
+ return success;
+ }
}
/** Called after open documents have been saved, prior to starting the blaze sync. */
diff --git a/base/src/com/google/idea/blaze/base/sync/actions/ExpandSyncToWorkingSetAction.java b/base/src/com/google/idea/blaze/base/sync/actions/ExpandSyncToWorkingSetAction.java
index 0509cca..54f2ca1 100644
--- a/base/src/com/google/idea/blaze/base/sync/actions/ExpandSyncToWorkingSetAction.java
+++ b/base/src/com/google/idea/blaze/base/sync/actions/ExpandSyncToWorkingSetAction.java
@@ -15,12 +15,12 @@
*/
package com.google.idea.blaze.base.sync.actions;
-import com.google.idea.blaze.base.actions.BlazeToggleAction;
+import com.google.idea.blaze.base.actions.BlazeProjectToggleAction;
import com.google.idea.blaze.base.settings.BlazeUserSettings;
import com.intellij.openapi.actionSystem.AnActionEvent;
/** Manages a tick box of whether to expand the sync targets to the working set. */
-public class ExpandSyncToWorkingSetAction extends BlazeToggleAction {
+public class ExpandSyncToWorkingSetAction extends BlazeProjectToggleAction {
@Override
public boolean isSelected(AnActionEvent e) {
return BlazeUserSettings.getInstance().getExpandSyncToWorkingSet();
diff --git a/base/src/com/google/idea/blaze/base/sync/actions/FullSyncProjectAction.java b/base/src/com/google/idea/blaze/base/sync/actions/FullSyncProjectAction.java
index 2c1f625..dfe752e 100644
--- a/base/src/com/google/idea/blaze/base/sync/actions/FullSyncProjectAction.java
+++ b/base/src/com/google/idea/blaze/base/sync/actions/FullSyncProjectAction.java
@@ -15,38 +15,29 @@
*/
package com.google.idea.blaze.base.sync.actions;
-import com.google.idea.blaze.base.actions.BlazeAction;
-import com.google.idea.blaze.base.settings.BlazeUserSettings;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.sync.BlazeSyncManager;
-import com.google.idea.blaze.base.sync.BlazeSyncParams;
-import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
+import com.google.idea.blaze.base.sync.status.BlazeSyncStatus;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.Presentation;
import com.intellij.openapi.project.Project;
-/** Re-imports (syncs) an Android-Blaze project, without showing the "Import Project" wizard. */
-public class FullSyncProjectAction extends BlazeAction {
+/** Performs a full sync. This is like an incremental sync with some additional invalidation. */
+public class FullSyncProjectAction extends BlazeProjectAction {
- public FullSyncProjectAction() {
- super("Non-Incrementally Sync Project with BUILD Files");
+ @Override
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
+ BlazeSyncManager.getInstance(project).fullProjectSync();
+ updateStatus(project, e);
}
@Override
- public void actionPerformed(final AnActionEvent e) {
- Project project = e.getProject();
- if (project != null) {
- Presentation presentation = e.getPresentation();
- presentation.setEnabled(false);
- try {
- BlazeSyncParams syncParams =
- new BlazeSyncParams.Builder("Full Sync", SyncMode.FULL)
- .addProjectViewTargets(true)
- .addWorkingSet(BlazeUserSettings.getInstance().getExpandSyncToWorkingSet())
- .build();
- BlazeSyncManager.getInstance(project).requestProjectSync(syncParams);
- } finally {
- presentation.setEnabled(true);
- }
- }
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
+ updateStatus(project, e);
+ }
+
+ private static void updateStatus(Project project, AnActionEvent e) {
+ Presentation presentation = e.getPresentation();
+ presentation.setEnabled(!BlazeSyncStatus.getInstance(project).syncInProgress());
}
}
diff --git a/base/src/com/google/idea/blaze/base/sync/actions/IncrementalSyncProjectAction.java b/base/src/com/google/idea/blaze/base/sync/actions/IncrementalSyncProjectAction.java
index 134acfb..f772b67 100644
--- a/base/src/com/google/idea/blaze/base/sync/actions/IncrementalSyncProjectAction.java
+++ b/base/src/com/google/idea/blaze/base/sync/actions/IncrementalSyncProjectAction.java
@@ -15,14 +15,11 @@
*/
package com.google.idea.blaze.base.sync.actions;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.settings.BlazeUserSettings;
import com.google.idea.blaze.base.sync.BlazeSyncManager;
-import com.google.idea.blaze.base.sync.BlazeSyncParams;
-import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
import com.google.idea.blaze.base.sync.status.BlazeSyncStatus;
-import com.google.idea.blaze.base.sync.status.BlazeSyncStatusImpl;
import com.intellij.notification.Notification;
import com.intellij.notification.NotificationDisplayType;
import com.intellij.notification.NotificationGroup;
@@ -34,45 +31,27 @@
import icons.BlazeIcons;
import javax.swing.Icon;
-/** Re-imports (syncs) an Android-Blaze project, without showing the "Import Project" wizard. */
-public class IncrementalSyncProjectAction extends BlazeAction {
+/** Syncs the project with BUILD files. */
+public class IncrementalSyncProjectAction extends BlazeProjectAction {
- public IncrementalSyncProjectAction() {
- super("Sync Project with BUILD Files");
+ @Override
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
+ BlazeSyncManager.getInstance(project).incrementalProjectSync();
+ updateIcon(e);
}
@Override
- public void actionPerformed(final AnActionEvent e) {
- Project project = e.getProject();
- if (project != null) {
- BlazeSyncManager.getInstance(project)
- .requestProjectSync(
- new BlazeSyncParams.Builder("Sync", SyncMode.INCREMENTAL)
- .addProjectViewTargets(true)
- .addWorkingSet(BlazeUserSettings.getInstance().getExpandSyncToWorkingSet())
- .build());
- updateIcon(e);
- }
- }
-
- @Override
- protected void doUpdate(AnActionEvent e) {
- super.doUpdate(e);
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
updateIcon(e);
}
private static void updateIcon(AnActionEvent e) {
Project project = e.getProject();
Presentation presentation = e.getPresentation();
- if (project == null) {
- presentation.setIcon(BlazeIcons.Blaze);
- presentation.setEnabled(true);
- return;
- }
- BlazeSyncStatusImpl statusHelper = BlazeSyncStatusImpl.getImpl(project);
+ BlazeSyncStatus statusHelper = BlazeSyncStatus.getInstance(project);
BlazeSyncStatus.SyncStatus status = statusHelper.getStatus();
presentation.setIcon(getIcon(status));
- presentation.setEnabled(!statusHelper.syncInProgress.get());
+ presentation.setEnabled(!statusHelper.syncInProgress());
if (status == BlazeSyncStatus.SyncStatus.DIRTY
&& !BlazeUserSettings.getInstance().getSyncStatusPopupShown()) {
diff --git a/base/src/com/google/idea/blaze/base/sync/actions/PartialSyncAction.java b/base/src/com/google/idea/blaze/base/sync/actions/PartialSyncAction.java
index e761f11..60e8484 100644
--- a/base/src/com/google/idea/blaze/base/sync/actions/PartialSyncAction.java
+++ b/base/src/com/google/idea/blaze/base/sync/actions/PartialSyncAction.java
@@ -15,8 +15,9 @@
*/
package com.google.idea.blaze.base.sync.actions;
+import com.google.common.collect.ImmutableList;
import com.google.common.collect.Lists;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import com.google.idea.blaze.base.projectview.ProjectViewManager;
@@ -24,13 +25,13 @@
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.google.idea.blaze.base.sync.BlazeSyncManager;
-import com.google.idea.blaze.base.sync.BlazeSyncParams;
import com.google.idea.blaze.base.sync.BuildTargetFinder;
import com.google.idea.blaze.base.sync.projectview.ImportRoots;
+import com.google.idea.blaze.base.sync.status.BlazeSyncStatus;
import com.google.idea.blaze.base.targetmaps.SourceToTargetMap;
+import com.google.idea.common.actionhelper.ActionPresentationHelper;
import com.intellij.openapi.actionSystem.AnActionEvent;
import com.intellij.openapi.actionSystem.CommonDataKeys;
-import com.intellij.openapi.actionSystem.Presentation;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.vfs.VirtualFile;
import java.io.File;
@@ -38,57 +39,43 @@
import javax.annotation.Nullable;
/** Allows a partial sync of the project depending on what's been selected. */
-public class PartialSyncAction extends BlazeAction {
+public class PartialSyncAction extends BlazeProjectAction {
+
@Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- if (project != null) {
- List<TargetExpression> targetExpressions = Lists.newArrayList();
- getTargets(e, targetExpressions);
-
- BlazeSyncParams syncParams =
- new BlazeSyncParams.Builder("Partial Sync", BlazeSyncParams.SyncMode.PARTIAL)
- .addTargetExpressions(targetExpressions)
- .build();
-
- BlazeSyncManager.getInstance(project).requestProjectSync(syncParams);
- }
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
+ VirtualFile virtualFile = getSelectedFile(e);
+ List<TargetExpression> targets = getTargets(project, virtualFile);
+ BlazeSyncManager.getInstance(project).partialSync(targets);
}
@Override
- protected void doUpdate(AnActionEvent e) {
- super.doUpdate(e);
- List<TargetExpression> targets = Lists.newArrayList();
- String objectName = getTargets(e, targets);
-
- boolean enabled = objectName != null && !targets.isEmpty();
- Presentation presentation = e.getPresentation();
- presentation.setEnabled(enabled);
-
- if (enabled) {
- presentation.setText(
- String.format("Partially Sync %s with %s", objectName, buildSystemName(e.getProject())));
- } else {
- presentation.setText(String.format("Partial %s Sync", buildSystemName(e.getProject())));
- }
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
+ VirtualFile virtualFile = getSelectedFile(e);
+ List<TargetExpression> targets = getTargets(project, virtualFile);
+ ActionPresentationHelper.of(e)
+ .disableIf(BlazeSyncStatus.getInstance(project).syncInProgress())
+ .disableIf(targets.isEmpty())
+ .setTextWithSubject("Partially Sync File", "Partially Sync %s", virtualFile)
+ .disableWithoutSubject()
+ .commit();
}
- private static String buildSystemName(@Nullable Project project) {
- return Blaze.buildSystemName(project);
- }
-
- @Nullable
- private String getTargets(AnActionEvent e, List<TargetExpression> targets) {
- Project project = e.getProject();
+ private VirtualFile getSelectedFile(AnActionEvent e) {
VirtualFile virtualFile = e.getData(CommonDataKeys.VIRTUAL_FILE);
- if (project == null || virtualFile == null || !virtualFile.isInLocalFileSystem()) {
+ if (virtualFile == null || !virtualFile.isInLocalFileSystem()) {
return null;
}
+ return virtualFile;
+ }
+ private static List<TargetExpression> getTargets(
+ Project project, @Nullable VirtualFile virtualFile) {
+ if (virtualFile == null) {
+ return ImmutableList.of();
+ }
+ List<TargetExpression> targets = Lists.newArrayList();
WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
SourceToTargetMap.getInstance(project);
-
- String objectName = virtualFile.isDirectory() ? "Package" : "File";
if (!virtualFile.isDirectory()) {
targets.addAll(
SourceToTargetMap.getInstance(project)
@@ -109,7 +96,6 @@
}
}
}
-
- return objectName;
+ return targets;
}
}
diff --git a/base/src/com/google/idea/blaze/base/sync/actions/ShowPerformanceWarningsToggleAction.java b/base/src/com/google/idea/blaze/base/sync/actions/ShowPerformanceWarningsToggleAction.java
index d7c6e96..9cb2b46 100644
--- a/base/src/com/google/idea/blaze/base/sync/actions/ShowPerformanceWarningsToggleAction.java
+++ b/base/src/com/google/idea/blaze/base/sync/actions/ShowPerformanceWarningsToggleAction.java
@@ -15,12 +15,12 @@
*/
package com.google.idea.blaze.base.sync.actions;
-import com.google.idea.blaze.base.actions.BlazeToggleAction;
+import com.google.idea.blaze.base.actions.BlazeProjectToggleAction;
import com.google.idea.blaze.base.settings.BlazeUserSettings;
import com.intellij.openapi.actionSystem.AnActionEvent;
/** Manages a tick box of whether to show performance warnings. */
-public class ShowPerformanceWarningsToggleAction extends BlazeToggleAction {
+public class ShowPerformanceWarningsToggleAction extends BlazeProjectToggleAction {
@Override
public boolean isSelected(AnActionEvent e) {
return BlazeUserSettings.getInstance().getShowPerformanceWarnings();
diff --git a/base/src/com/google/idea/blaze/base/sync/actions/SyncWorkingSetAction.java b/base/src/com/google/idea/blaze/base/sync/actions/SyncWorkingSetAction.java
index 950f473..f72294b 100644
--- a/base/src/com/google/idea/blaze/base/sync/actions/SyncWorkingSetAction.java
+++ b/base/src/com/google/idea/blaze/base/sync/actions/SyncWorkingSetAction.java
@@ -15,25 +15,29 @@
*/
package com.google.idea.blaze.base.sync.actions;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.sync.BlazeSyncManager;
-import com.google.idea.blaze.base.sync.BlazeSyncParams;
-import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
+import com.google.idea.blaze.base.sync.status.BlazeSyncStatus;
import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.Presentation;
import com.intellij.openapi.project.Project;
-/** Allows a partial sync of the project depending on what's been selected. */
-public class SyncWorkingSetAction extends BlazeAction {
- @Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- if (project != null) {
- BlazeSyncParams syncParams =
- new BlazeSyncParams.Builder("Sync Working Set", SyncMode.PARTIAL)
- .addWorkingSet(true)
- .build();
+/** Allows a partial sync of the working set. */
+public class SyncWorkingSetAction extends BlazeProjectAction {
- BlazeSyncManager.getInstance(project).requestProjectSync(syncParams);
- }
+ @Override
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
+ BlazeSyncManager.getInstance(project).workingSetSync();
+ updateStatus(project, e);
+ }
+
+ @Override
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
+ updateStatus(project, e);
+ }
+
+ private static void updateStatus(Project project, AnActionEvent e) {
+ Presentation presentation = e.getPresentation();
+ presentation.setEnabled(!BlazeSyncStatus.getInstance(project).syncInProgress());
}
}
diff --git a/base/src/com/google/idea/blaze/base/sync/aspects/BlazeIdeInterface.java b/base/src/com/google/idea/blaze/base/sync/aspects/BlazeIdeInterface.java
index 4051083..c355d5d 100644
--- a/base/src/com/google/idea/blaze/base/sync/aspects/BlazeIdeInterface.java
+++ b/base/src/com/google/idea/blaze/base/sync/aspects/BlazeIdeInterface.java
@@ -16,6 +16,7 @@
package com.google.idea.blaze.base.sync.aspects;
import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
@@ -73,6 +74,7 @@
BlazeContext context,
WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
List<TargetExpression> targets,
WorkspaceLanguageSettings workspaceLanguageSettings,
ArtifactLocationDecoder artifactLocationDecoder,
@@ -90,5 +92,19 @@
BlazeContext context,
WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
+ List<TargetExpression> targets);
+
+ /**
+ * Attempts to compile the requested ide artifacts.
+ *
+ * <p>Amounts to a build of the ide-compile output group.
+ */
+ BuildResult compileIdeArtifacts(
+ Project project,
+ BlazeContext context,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
List<TargetExpression> targets);
}
diff --git a/base/src/com/google/idea/blaze/base/sync/aspects/BlazeIdeInterfaceAspectsImpl.java b/base/src/com/google/idea/blaze/base/sync/aspects/BlazeIdeInterfaceAspectsImpl.java
index f44f200..36e29af 100644
--- a/base/src/com/google/idea/blaze/base/sync/aspects/BlazeIdeInterfaceAspectsImpl.java
+++ b/base/src/com/google/idea/blaze/base/sync/aspects/BlazeIdeInterfaceAspectsImpl.java
@@ -36,6 +36,7 @@
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.issueparser.IssueOutputLineProcessor;
import com.google.idea.blaze.base.metrics.Action;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
@@ -91,6 +92,7 @@
BlazeContext context,
WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
List<TargetExpression> targets,
WorkspaceLanguageSettings workspaceLanguageSettings,
ArtifactLocationDecoder artifactLocationDecoder,
@@ -106,7 +108,7 @@
}
// If the aspect strategy has changed, redo everything from scratch
- final AspectStrategy aspectStrategy = getAspectStrategy(project);
+ final AspectStrategy aspectStrategy = getAspectStrategy(project, blazeVersionData);
if (prevState != null
&& !Objects.equal(prevState.aspectStrategyName, aspectStrategy.getName())) {
prevState = null;
@@ -375,8 +377,38 @@
BlazeContext context,
WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
List<TargetExpression> targets) {
- AspectStrategy aspectStrategy = getAspectStrategy(project);
+ return resolveIdeArtifacts(
+ project, context, workspaceRoot, projectViewSet, blazeVersionData, targets, false);
+ }
+
+ @Override
+ public BuildResult compileIdeArtifacts(
+ Project project,
+ BlazeContext context,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
+ List<TargetExpression> targets) {
+ boolean ideCompile = hasIdeCompileOutputGroup(blazeVersionData);
+ return resolveIdeArtifacts(
+ project, context, workspaceRoot, projectViewSet, blazeVersionData, targets, ideCompile);
+ }
+
+ private static boolean hasIdeCompileOutputGroup(BlazeVersionData blazeVersionData) {
+ return blazeVersionData.bazelIsAtLeastVersion(0, 4, 3);
+ }
+
+ private static BuildResult resolveIdeArtifacts(
+ Project project,
+ BlazeContext context,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
+ List<TargetExpression> targets,
+ boolean useIdeCompileOutputGroup) {
+ AspectStrategy aspectStrategy = getAspectStrategy(project, blazeVersionData);
BlazeCommand.Builder blazeCommandBuilder =
BlazeCommand.builder(Blaze.getBuildSystem(project), BlazeCommandName.BUILD)
@@ -385,7 +417,11 @@
.addBlazeFlags(BlazeFlags.KEEP_GOING)
.addBlazeFlags(BlazeFlags.buildFlags(project, projectViewSet));
- aspectStrategy.modifyIdeResolveCommand(blazeCommandBuilder);
+ if (useIdeCompileOutputGroup) {
+ aspectStrategy.modifyIdeCompileCommand(blazeCommandBuilder);
+ } else {
+ aspectStrategy.modifyIdeResolveCommand(blazeCommandBuilder);
+ }
BlazeCommand blazeCommand = blazeCommandBuilder.build();
@@ -402,9 +438,10 @@
return BuildResult.fromExitCode(retVal);
}
- private static AspectStrategy getAspectStrategy(Project project) {
+ private static AspectStrategy getAspectStrategy(
+ Project project, BlazeVersionData blazeVersionData) {
for (AspectStrategyProvider provider : AspectStrategyProvider.EP_NAME.getExtensions()) {
- AspectStrategy aspectStrategy = provider.getAspectStrategy(project);
+ AspectStrategy aspectStrategy = provider.getAspectStrategy(project, blazeVersionData);
if (aspectStrategy != null) {
return aspectStrategy;
}
diff --git a/base/src/com/google/idea/blaze/base/sync/aspects/IdeInfoFromProtobuf.java b/base/src/com/google/idea/blaze/base/sync/aspects/IdeInfoFromProtobuf.java
index f3f0557..c140587 100644
--- a/base/src/com/google/idea/blaze/base/sync/aspects/IdeInfoFromProtobuf.java
+++ b/base/src/com/google/idea/blaze/base/sync/aspects/IdeInfoFromProtobuf.java
@@ -150,8 +150,7 @@
}
private static TargetKey makeTargetKey(IntellijIdeInfo.TargetKey key) {
- return TargetKey.forGeneralTarget(
- new Label(key.getLabel()), Strings.emptyToNull(key.getAspectId()));
+ return TargetKey.forGeneralTarget(new Label(key.getLabel()), key.getAspectIdsList());
}
private static Dependency makeDependency(IntellijIdeInfo.Dependency dep) {
diff --git a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategy.java b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategy.java
index 598d8b6..d63630e 100644
--- a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategy.java
+++ b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategy.java
@@ -28,6 +28,8 @@
void modifyIdeResolveCommand(BlazeCommand.Builder blazeCommandBuilder);
+ void modifyIdeCompileCommand(BlazeCommand.Builder blazeCommandBuilder);
+
String getAspectOutputFileExtension();
IntellijIdeInfo.TargetIdeInfo readAspectFile(InputStream inputStream) throws IOException;
diff --git a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyNative.java b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyNative.java
index df88c4f..63787db 100644
--- a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyNative.java
+++ b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyNative.java
@@ -22,6 +22,7 @@
/** Aspect strategy for native. */
public class AspectStrategyNative implements AspectStrategy {
+
@Override
public String getName() {
return "NativeAspect";
@@ -42,6 +43,13 @@
}
@Override
+ public void modifyIdeCompileCommand(BlazeCommand.Builder blazeCommandBuilder) {
+ blazeCommandBuilder
+ .addBlazeFlags("--aspects=AndroidStudioInfoAspect")
+ .addBlazeFlags("--output_groups=ide-compile");
+ }
+
+ @Override
public String getAspectOutputFileExtension() {
return ".aswb-build";
}
diff --git a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyProvider.java b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyProvider.java
index 0fdd2b5..13c7586 100644
--- a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyProvider.java
+++ b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyProvider.java
@@ -15,6 +15,7 @@
*/
package com.google.idea.blaze.base.sync.aspects.strategy;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.project.Project;
import javax.annotation.Nullable;
@@ -25,5 +26,5 @@
ExtensionPointName.create("com.google.idea.blaze.AspectStrategyProvider");
@Nullable
- AspectStrategy getAspectStrategy(Project project);
+ AspectStrategy getAspectStrategy(Project project, BlazeVersionData blazeVersionData);
}
diff --git a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyProviderBazel.java b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyProviderBazel.java
index 9042523..f3b1029 100644
--- a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyProviderBazel.java
+++ b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategyProviderBazel.java
@@ -15,14 +15,19 @@
*/
package com.google.idea.blaze.base.sync.aspects.strategy;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.common.experiments.BoolExperiment;
import com.intellij.openapi.project.Project;
class AspectStrategyProviderBazel implements AspectStrategyProvider {
- BoolExperiment useSkylarkAspect = new BoolExperiment("use.skylark.aspect.bazel", false);
+ private static final BoolExperiment useSkylarkAspect =
+ new BoolExperiment("use.skylark.aspect.bazel", true);
@Override
- public AspectStrategy getAspectStrategy(Project project) {
- return useSkylarkAspect.getValue() ? new AspectStrategySkylark() : new AspectStrategyNative();
+ public AspectStrategy getAspectStrategy(Project project, BlazeVersionData blazeVersionData) {
+ boolean canUseSkylark =
+ useSkylarkAspect.getValue() && blazeVersionData.bazelIsAtLeastVersion(0, 4, 3);
+
+ return canUseSkylark ? new AspectStrategySkylark() : new AspectStrategyNative();
}
}
diff --git a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategySkylark.java b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategySkylark.java
index 0139f87..aa3eadc 100644
--- a/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategySkylark.java
+++ b/base/src/com/google/idea/blaze/base/sync/aspects/strategy/AspectStrategySkylark.java
@@ -18,6 +18,7 @@
import static java.nio.charset.StandardCharsets.UTF_8;
import com.google.idea.blaze.base.command.BlazeCommand;
+import com.google.idea.blaze.base.command.BlazeCommand.Builder;
import com.google.repackaged.devtools.intellij.ideinfo.IntellijIdeInfo;
import com.google.repackaged.protobuf.TextFormat;
import java.io.IOException;
@@ -33,7 +34,7 @@
}
protected String getAspectFlag() {
- return "--aspects=@bazel_tools://tools/ide/intellij_info.bzl%intellij_info_aspect";
+ return "--aspects=@bazel_tools//tools/ide:intellij_info.bzl%intellij_info_aspect";
}
@Override
@@ -51,6 +52,13 @@
}
@Override
+ public void modifyIdeCompileCommand(Builder blazeCommandBuilder) {
+ blazeCommandBuilder
+ .addBlazeFlags(getAspectFlag())
+ .addBlazeFlags("--output_groups=intellij-compile");
+ }
+
+ @Override
public String getAspectOutputFileExtension() {
return ".intellij-info.txt";
}
diff --git a/base/src/com/google/idea/blaze/base/sync/projectstructure/ContentEntryEditor.java b/base/src/com/google/idea/blaze/base/sync/projectstructure/ContentEntryEditor.java
index 871274e..d8e72f6 100644
--- a/base/src/com/google/idea/blaze/base/sync/projectstructure/ContentEntryEditor.java
+++ b/base/src/com/google/idea/blaze/base/sync/projectstructure/ContentEntryEditor.java
@@ -24,6 +24,7 @@
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.scope.output.IssueOutput;
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.sync.SourceFolderProvider;
import com.google.idea.blaze.base.sync.projectview.ImportRoots;
@@ -82,6 +83,15 @@
ImmutableMap<VirtualFile, SourceFolder> sourceFolders =
provider.initializeSourceFolders(contentEntry);
VirtualFile rootFile = getVirtualFile(root);
+ if (rootFile == null) {
+ IssueOutput.warn(
+ String.format(
+ "Could not find directory %s. Your 'test_sources' project view "
+ + "attribute will not have any effect. Please resync.",
+ workspaceRoot))
+ .submit(context);
+ continue;
+ }
SourceFolder rootSource = sourceFolders.get(rootFile);
walkFileSystem(
workspaceRoot,
@@ -121,11 +131,11 @@
SourceFolder current = sourceFolders.get(file);
SourceFolder currentOrParent = current != null ? current : parent;
if (isTest != currentOrParent.isTestSource()) {
+ currentOrParent =
+ provider.setSourceFolderForLocation(contentEntry, currentOrParent, file, isTest);
if (current != null) {
contentEntry.removeSourceFolder(current);
}
- currentOrParent =
- provider.setSourceFolderForLocation(contentEntry, currentOrParent, file, isTest);
}
for (VirtualFile child : file.getChildren()) {
walkFileSystem(
diff --git a/base/src/com/google/idea/blaze/base/sync/status/BlazeSyncStatus.java b/base/src/com/google/idea/blaze/base/sync/status/BlazeSyncStatus.java
index aa98c7e..a1e3f7c 100644
--- a/base/src/com/google/idea/blaze/base/sync/status/BlazeSyncStatus.java
+++ b/base/src/com/google/idea/blaze/base/sync/status/BlazeSyncStatus.java
@@ -30,10 +30,13 @@
SyncStatus getStatus();
+
static BlazeSyncStatus getInstance(Project project) {
return ServiceManager.getService(project, BlazeSyncStatus.class);
}
+ boolean syncInProgress();
+
void setDirty();
void queueAutomaticSyncIfDirty();
diff --git a/base/src/com/google/idea/blaze/base/sync/status/BlazeSyncStatusImpl.java b/base/src/com/google/idea/blaze/base/sync/status/BlazeSyncStatusImpl.java
index 396f27d..ee60cd7 100644
--- a/base/src/com/google/idea/blaze/base/sync/status/BlazeSyncStatusImpl.java
+++ b/base/src/com/google/idea/blaze/base/sync/status/BlazeSyncStatusImpl.java
@@ -23,7 +23,6 @@
import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
import com.google.idea.blaze.base.sync.SyncListener.SyncResult;
import com.intellij.openapi.diagnostic.Logger;
-import com.intellij.openapi.editor.Document;
import com.intellij.openapi.fileEditor.FileDocumentManager;
import com.intellij.openapi.fileEditor.FileEditorManager;
import com.intellij.openapi.fileEditor.FileEditorManagerAdapter;
@@ -54,7 +53,7 @@
private final Project project;
- public final AtomicBoolean syncInProgress = new AtomicBoolean(false);
+ private final AtomicBoolean syncInProgress = new AtomicBoolean(false);
private final AtomicBoolean syncPending = new AtomicBoolean(false);
/** has a BUILD file changed since the last sync started */
@@ -86,6 +85,11 @@
return dirty ? SyncStatus.DIRTY : SyncStatus.CLEAN;
}
+ @Override
+ public boolean syncInProgress() {
+ return syncInProgress.get();
+ }
+
public void syncStarted() {
syncPending.set(false);
syncInProgress.set(true);
@@ -189,10 +193,9 @@
private void processEvent(@Nullable VirtualFile file) {
if (isSyncSensitiveFile(file)) {
- FileDocumentManager manager = FileDocumentManager.getInstance();
- Document doc = manager.getCachedDocument(file);
- if (doc != null) {
- manager.saveDocument(doc);
+ FileDocumentManager fileDocumentManager = FileDocumentManager.getInstance();
+ if (fileDocumentManager.isFileModified(file)) {
+ setDirty();
}
}
}
diff --git a/base/src/com/google/idea/blaze/base/targetmaps/TransitiveDependencyMap.java b/base/src/com/google/idea/blaze/base/targetmaps/TransitiveDependencyMap.java
new file mode 100644
index 0000000..f973c8d
--- /dev/null
+++ b/base/src/com/google/idea/blaze/base/targetmaps/TransitiveDependencyMap.java
@@ -0,0 +1,79 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.targetmaps;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Queues;
+import com.google.common.collect.Sets;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.intellij.openapi.components.ServiceManager;
+import com.intellij.openapi.project.Project;
+import java.util.List;
+import java.util.Queue;
+import java.util.Set;
+import java.util.stream.Collectors;
+
+/** Handy class to find all transitive dependencies of a given target */
+public class TransitiveDependencyMap {
+ private final Project project;
+
+ public static TransitiveDependencyMap getInstance(Project project) {
+ return ServiceManager.getService(project, TransitiveDependencyMap.class);
+ }
+
+ public TransitiveDependencyMap(Project project) {
+ this.project = project;
+ }
+
+ public ImmutableCollection<TargetKey> getTransitiveDependencies(TargetKey targetKey) {
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+ if (blazeProjectData == null) {
+ return ImmutableSet.of();
+ }
+ // TODO: see if we need caching.
+ return getTransitiveDependencies(targetKey, blazeProjectData.targetMap);
+ }
+
+ private static ImmutableCollection<TargetKey> getTransitiveDependencies(
+ TargetKey targetKey, TargetMap targetMap) {
+ Queue<TargetKey> targetsToVisit = Queues.newArrayDeque();
+ Set<TargetKey> transitiveDependencies = Sets.newHashSet();
+ targetsToVisit.add(targetKey);
+ while (!targetsToVisit.isEmpty()) {
+ TargetIdeInfo currentTarget = targetMap.get(targetsToVisit.remove());
+ if (currentTarget == null) {
+ continue;
+ }
+ List<TargetKey> newDependencies =
+ currentTarget
+ .dependencies
+ .stream()
+ .map(d -> TargetKey.forPlainTarget(d.targetKey.label))
+ // Get rid of the ones we've already seen.
+ .filter(r -> !transitiveDependencies.contains(r))
+ .collect(Collectors.toList());
+ targetsToVisit.addAll(newDependencies);
+ transitiveDependencies.addAll(newDependencies);
+ }
+ return ImmutableSet.copyOf(transitiveDependencies);
+ }
+}
diff --git a/base/src/com/google/idea/blaze/base/util/SaveUtil.java b/base/src/com/google/idea/blaze/base/util/SaveUtil.java
index 6454a7a..949f201 100644
--- a/base/src/com/google/idea/blaze/base/util/SaveUtil.java
+++ b/base/src/com/google/idea/blaze/base/util/SaveUtil.java
@@ -15,18 +15,13 @@
*/
package com.google.idea.blaze.base.util;
+import com.google.idea.sdkcompat.transactions.Transactions;
import com.intellij.openapi.fileEditor.FileDocumentManager;
-import com.intellij.util.ui.UIUtil;
/** Utility for saving all files. */
public class SaveUtil {
public static void saveAllFiles() {
- UIUtil.invokeAndWaitIfNeeded(
- new Runnable() {
- @Override
- public void run() {
- FileDocumentManager.getInstance().saveAllDocuments();
- }
- });
+ Transactions.submitTransactionAndWait(
+ () -> FileDocumentManager.getInstance().saveAllDocuments());
}
}
diff --git a/base/src/com/google/idea/blaze/base/vcs/BlazeVcsHandler.java b/base/src/com/google/idea/blaze/base/vcs/BlazeVcsHandler.java
index 16e6909..b05e69a 100644
--- a/base/src/com/google/idea/blaze/base/vcs/BlazeVcsHandler.java
+++ b/base/src/com/google/idea/blaze/base/vcs/BlazeVcsHandler.java
@@ -20,6 +20,7 @@
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.google.idea.blaze.base.sync.workspace.BlazeRoots;
import com.google.idea.blaze.base.sync.workspace.WorkingSet;
@@ -33,6 +34,18 @@
ExtensionPointName<BlazeVcsHandler> EP_NAME =
ExtensionPointName.create("com.google.idea.blaze.VcsHandler");
+ @Nullable
+ static BlazeVcsHandler vcsHandlerForProject(Project project) {
+ BuildSystem buildSystem = Blaze.getBuildSystem(project);
+ WorkspaceRoot workspaceRoot = WorkspaceRoot.fromProject(project);
+ for (BlazeVcsHandler candidate : BlazeVcsHandler.EP_NAME.getExtensions()) {
+ if (candidate.handlesProject(buildSystem, workspaceRoot)) {
+ return candidate;
+ }
+ }
+ return null;
+ }
+
/** Returns the name of this VCS, eg. "git" or "hg" */
String getVcsName();
diff --git a/base/src/com/google/idea/blaze/base/wizard2/BlazeWizardOptionProvider.java b/base/src/com/google/idea/blaze/base/wizard2/BlazeWizardOptionProvider.java
index 20a7e4d..1739755 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/BlazeWizardOptionProvider.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/BlazeWizardOptionProvider.java
@@ -15,16 +15,17 @@
*/
package com.google.idea.blaze.base.wizard2;
-import com.intellij.openapi.extensions.ExtensionPointName;
+import com.intellij.openapi.components.ServiceManager;
import java.util.Collection;
/** Provides options during the import process. */
public interface BlazeWizardOptionProvider {
- ExtensionPointName<BlazeWizardOptionProvider> EP_NAME =
- ExtensionPointName.create("com.google.idea.blaze.BlazeWizardOptionProvider");
-
Collection<BlazeSelectWorkspaceOption> getSelectWorkspaceOptions(BlazeNewProjectBuilder builder);
Collection<BlazeSelectProjectViewOption> getSelectProjectViewOptions(
BlazeNewProjectBuilder builder);
+
+ static BlazeWizardOptionProvider getInstance() {
+ return ServiceManager.getService(BlazeWizardOptionProvider.class);
+ }
}
diff --git a/base/src/com/google/idea/blaze/base/wizard2/CopyExternalProjectViewOption.java b/base/src/com/google/idea/blaze/base/wizard2/CopyExternalProjectViewOption.java
index 62db2c5..ae00949 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/CopyExternalProjectViewOption.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/CopyExternalProjectViewOption.java
@@ -35,14 +35,15 @@
import javax.swing.JComponent;
import javax.swing.JLabel;
-class CopyExternalProjectViewOption implements BlazeSelectProjectViewOption {
+/** Copies an external project view from anywhere on the user's file system */
+public class CopyExternalProjectViewOption implements BlazeSelectProjectViewOption {
private static final String LAST_WORKSPACE_PATH = "copy-external.last-project-view-path";
final BlazeWizardUserSettings userSettings;
final JComponent component;
final TextFieldWithStoredHistory projectViewPathField;
- CopyExternalProjectViewOption(BlazeNewProjectBuilder builder) {
+ public CopyExternalProjectViewOption(BlazeNewProjectBuilder builder) {
this.userSettings = builder.getUserSettings();
this.projectViewPathField = new TextFieldWithStoredHistory(LAST_WORKSPACE_PATH);
diff --git a/base/src/com/google/idea/blaze/base/wizard2/CreateFromScratchProjectViewOption.java b/base/src/com/google/idea/blaze/base/wizard2/CreateFromScratchProjectViewOption.java
index 366e424..3e8ebf7 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/CreateFromScratchProjectViewOption.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/CreateFromScratchProjectViewOption.java
@@ -19,7 +19,8 @@
import javax.annotation.Nullable;
import javax.swing.JComponent;
-class CreateFromScratchProjectViewOption implements BlazeSelectProjectViewOption {
+/** Creates an empty project view */
+public class CreateFromScratchProjectViewOption implements BlazeSelectProjectViewOption {
@Override
public String getOptionName() {
return "create-from-scratch";
diff --git a/base/src/com/google/idea/blaze/base/wizard2/GenerateFromBuildFileSelectProjectViewOption.java b/base/src/com/google/idea/blaze/base/wizard2/GenerateFromBuildFileSelectProjectViewOption.java
index e2e41d9..b2edeff 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/GenerateFromBuildFileSelectProjectViewOption.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/GenerateFromBuildFileSelectProjectViewOption.java
@@ -45,7 +45,8 @@
import javax.swing.JComponent;
import javax.swing.JLabel;
-class GenerateFromBuildFileSelectProjectViewOption implements BlazeSelectProjectViewOption {
+/** Generates a project view given a BUILD file */
+public class GenerateFromBuildFileSelectProjectViewOption implements BlazeSelectProjectViewOption {
private static final String LAST_WORKSPACE_PATH = "generate-from-build-file.last-workspace-path";
private final BlazeNewProjectBuilder builder;
private final BlazeWizardUserSettings userSettings;
diff --git a/base/src/com/google/idea/blaze/base/wizard2/ImportFromWorkspaceProjectViewOption.java b/base/src/com/google/idea/blaze/base/wizard2/ImportFromWorkspaceProjectViewOption.java
index c2d47e1..bdec2eb 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/ImportFromWorkspaceProjectViewOption.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/ImportFromWorkspaceProjectViewOption.java
@@ -39,7 +39,8 @@
import javax.swing.JComponent;
import javax.swing.JLabel;
-class ImportFromWorkspaceProjectViewOption implements BlazeSelectProjectViewOption {
+/** Imports a project view from source control */
+public class ImportFromWorkspaceProjectViewOption implements BlazeSelectProjectViewOption {
private static final String LAST_WORKSPACE_PATH = "import-from-workspace.last-workspace-path";
final BlazeNewProjectBuilder builder;
@@ -47,7 +48,7 @@
final JComponent component;
final TextFieldWithStoredHistory projectViewPathField;
- ImportFromWorkspaceProjectViewOption(BlazeNewProjectBuilder builder) {
+ public ImportFromWorkspaceProjectViewOption(BlazeNewProjectBuilder builder) {
this.builder = builder;
this.userSettings = builder.getUserSettings();
diff --git a/base/src/com/google/idea/blaze/base/wizard2/UseExistingBazelWorkspaceOption.java b/base/src/com/google/idea/blaze/base/wizard2/UseExistingBazelWorkspaceOption.java
index 2b8c058..51af079 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/UseExistingBazelWorkspaceOption.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/UseExistingBazelWorkspaceOption.java
@@ -36,12 +36,13 @@
import javax.swing.JComponent;
import javax.swing.JLabel;
-class UseExistingBazelWorkspaceOption implements BlazeSelectWorkspaceOption {
+/** Allows importing an existing bazel workspace */
+public class UseExistingBazelWorkspaceOption implements BlazeSelectWorkspaceOption {
private final JComponent component;
private final TextFieldWithHistory directoryField;
- UseExistingBazelWorkspaceOption(BlazeNewProjectBuilder builder) {
+ public UseExistingBazelWorkspaceOption(BlazeNewProjectBuilder builder) {
this.directoryField = new TextFieldWithHistory();
this.directoryField.setHistory(builder.getWorkspaceHistory(BuildSystem.Bazel));
this.directoryField.setHistorySize(BlazeNewProjectBuilder.HISTORY_SIZE);
diff --git a/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeEditProjectViewControl.java b/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeEditProjectViewControl.java
index 0307b5a..4f3be05 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeEditProjectViewControl.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeEditProjectViewControl.java
@@ -92,6 +92,7 @@
private JTextField projectNameField;
private HashCode paramsHash;
private WorkspaceRoot workspaceRoot;
+ private WorkspacePathResolver workspacePathResolver;
public BlazeEditProjectViewControl(BlazeNewProjectBuilder builder, Disposable parentDisposable) {
this.projectViewUi = new ProjectViewUi(parentDisposable);
@@ -209,6 +210,7 @@
}
this.workspaceRoot = workspaceRoot;
+ this.workspacePathResolver = workspacePathResolver;
projectNameField.setText(workspaceName);
String defaultDataDir = getDefaultProjectDataDirectory(workspaceName);
projectDataDirField.setText(defaultDataDir);
@@ -328,7 +330,8 @@
return BlazeValidationResult.failure(projectViewParseError);
}
- ProjectViewValidator projectViewValidator = new ProjectViewValidator(projectViewSet);
+ ProjectViewValidator projectViewValidator =
+ new ProjectViewValidator(workspacePathResolver, projectViewSet);
ProgressManager.getInstance()
.runProcessWithProgressSynchronously(
projectViewValidator, "Validating Project", false, null);
@@ -347,12 +350,15 @@
}
private static class ProjectViewValidator implements Runnable {
+ private final WorkspacePathResolver workspacePathResolver;
private final ProjectViewSet projectViewSet;
private boolean success;
List<IssueOutput> errors = Lists.newArrayList();
- ProjectViewValidator(ProjectViewSet projectViewSet) {
+ ProjectViewValidator(
+ WorkspacePathResolver workspacePathResolver, ProjectViewSet projectViewSet) {
+ this.workspacePathResolver = workspacePathResolver;
this.projectViewSet = projectViewSet;
}
@@ -379,8 +385,8 @@
if (workspaceLanguageSettings == null) {
return false;
}
- return ProjectViewVerifier.verifyProjectViewNoDisk(
- context, projectViewSet, workspaceLanguageSettings);
+ return ProjectViewVerifier.verifyProjectView(
+ context, workspacePathResolver, projectViewSet, workspaceLanguageSettings);
}
}
diff --git a/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeSelectProjectViewControl.java b/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeSelectProjectViewControl.java
index a2b6467..4dc04cd 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeSelectProjectViewControl.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeSelectProjectViewControl.java
@@ -15,7 +15,6 @@
*/
package com.google.idea.blaze.base.wizard2.ui;
-import com.google.common.collect.Lists;
import com.google.idea.blaze.base.projectview.ProjectViewStorageManager;
import com.google.idea.blaze.base.ui.BlazeValidationResult;
import com.google.idea.blaze.base.wizard2.BlazeNewProjectBuilder;
@@ -30,11 +29,8 @@
private BlazeSelectOptionControl<BlazeSelectProjectViewOption> selectOptionControl;
public BlazeSelectProjectViewControl(BlazeNewProjectBuilder builder) {
- Collection<BlazeSelectProjectViewOption> options = Lists.newArrayList();
- for (BlazeWizardOptionProvider optionProvider :
- BlazeWizardOptionProvider.EP_NAME.getExtensions()) {
- options.addAll(optionProvider.getSelectProjectViewOptions(builder));
- }
+ Collection<BlazeSelectProjectViewOption> options =
+ BlazeWizardOptionProvider.getInstance().getSelectProjectViewOptions(builder);
this.selectOptionControl =
new BlazeSelectOptionControl<BlazeSelectProjectViewOption>(builder, options) {
diff --git a/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeSelectWorkspaceControl.java b/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeSelectWorkspaceControl.java
index f0c6b45..e24b446 100644
--- a/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeSelectWorkspaceControl.java
+++ b/base/src/com/google/idea/blaze/base/wizard2/ui/BlazeSelectWorkspaceControl.java
@@ -15,7 +15,6 @@
*/
package com.google.idea.blaze.base.wizard2.ui;
-import com.google.common.collect.Lists;
import com.google.idea.blaze.base.ui.BlazeValidationResult;
import com.google.idea.blaze.base.wizard2.BlazeNewProjectBuilder;
import com.google.idea.blaze.base.wizard2.BlazeSelectWorkspaceOption;
@@ -28,11 +27,8 @@
BlazeSelectOptionControl<BlazeSelectWorkspaceOption> selectOptionControl;
public BlazeSelectWorkspaceControl(BlazeNewProjectBuilder builder) {
- Collection<BlazeSelectWorkspaceOption> options = Lists.newArrayList();
- for (BlazeWizardOptionProvider optionProvider :
- BlazeWizardOptionProvider.EP_NAME.getExtensions()) {
- options.addAll(optionProvider.getSelectWorkspaceOptions(builder));
- }
+ Collection<BlazeSelectWorkspaceOption> options =
+ BlazeWizardOptionProvider.getInstance().getSelectWorkspaceOptions(builder);
this.selectOptionControl =
new BlazeSelectOptionControl<BlazeSelectWorkspaceOption>(builder, options) {
diff --git a/base/tests/integrationtests/com/google/idea/blaze/base/lang/projectview/ProjectViewIntegrationTestCase.java b/base/tests/integrationtests/com/google/idea/blaze/base/lang/projectview/ProjectViewIntegrationTestCase.java
index 361b0bb..960660e 100644
--- a/base/tests/integrationtests/com/google/idea/blaze/base/lang/projectview/ProjectViewIntegrationTestCase.java
+++ b/base/tests/integrationtests/com/google/idea/blaze/base/lang/projectview/ProjectViewIntegrationTestCase.java
@@ -21,11 +21,12 @@
import com.google.idea.blaze.base.EditorTestHelper;
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
+import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.ExecutionRootPath;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoderImpl;
import com.google.idea.blaze.base.sync.workspace.BlazeRoots;
-import com.google.idea.blaze.base.sync.workspace.WorkingSet;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverImpl;
import org.junit.Before;
@@ -57,12 +58,11 @@
new TargetMap(ImmutableMap.of()),
ImmutableMap.of(),
fakeRoots,
- new WorkingSet(ImmutableList.of(), ImmutableList.of(), ImmutableList.of()),
+ new BlazeVersionData(),
workspacePathResolver,
artifactLocationDecoder,
null,
- null,
- null,
+ new SyncState.Builder().build(),
null);
}
}
diff --git a/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationGenericHandlerIntegrationTest.java b/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationGenericHandlerIntegrationTest.java
index c4f5242..eb8d69f 100644
--- a/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationGenericHandlerIntegrationTest.java
+++ b/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationGenericHandlerIntegrationTest.java
@@ -23,6 +23,7 @@
import com.google.idea.blaze.base.command.BlazeCommandName;
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.primitives.ExecutionRootPath;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration.BlazeCommandRunConfigurationSettingsEditor;
@@ -31,7 +32,6 @@
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoderImpl;
import com.google.idea.blaze.base.sync.workspace.BlazeRoots;
-import com.google.idea.blaze.base.sync.workspace.WorkingSet;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverImpl;
import com.intellij.openapi.options.ConfigurationException;
@@ -79,12 +79,11 @@
new TargetMap(ImmutableMap.of()),
ImmutableMap.of(),
fakeRoots,
- new WorkingSet(ImmutableList.of(), ImmutableList.of(), ImmutableList.of()),
+ new BlazeVersionData(),
workspacePathResolver,
artifactLocationDecoder,
null,
null,
- null,
null);
}
diff --git a/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationRunManagerImplTest.java b/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationRunManagerImplTest.java
index 6395e65..237fa7f 100644
--- a/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationRunManagerImplTest.java
+++ b/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationRunManagerImplTest.java
@@ -23,13 +23,13 @@
import com.google.idea.blaze.base.BlazeIntegrationTestCase;
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.primitives.ExecutionRootPath;
import com.google.idea.blaze.base.model.primitives.Label;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration.BlazeCommandRunConfigurationSettingsEditor;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoderImpl;
import com.google.idea.blaze.base.sync.workspace.BlazeRoots;
-import com.google.idea.blaze.base.sync.workspace.WorkingSet;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverImpl;
import com.intellij.execution.RunnerAndConfigurationSettings;
@@ -89,12 +89,11 @@
new TargetMap(ImmutableMap.of()),
ImmutableMap.of(),
fakeRoots,
- new WorkingSet(ImmutableList.of(), ImmutableList.of(), ImmutableList.of()),
+ new BlazeVersionData(),
workspacePathResolver,
artifactLocationDecoder,
null,
null,
- null,
null);
}
diff --git a/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationSettingsEditorTest.java b/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationSettingsEditorTest.java
index 336930a..b9a2b48 100644
--- a/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationSettingsEditorTest.java
+++ b/base/tests/integrationtests/com/google/idea/blaze/base/run/BlazeCommandRunConfigurationSettingsEditorTest.java
@@ -22,13 +22,13 @@
import com.google.idea.blaze.base.BlazeIntegrationTestCase;
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.primitives.ExecutionRootPath;
import com.google.idea.blaze.base.model.primitives.Label;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration.BlazeCommandRunConfigurationSettingsEditor;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoderImpl;
import com.google.idea.blaze.base.sync.workspace.BlazeRoots;
-import com.google.idea.blaze.base.sync.workspace.WorkingSet;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverImpl;
import com.intellij.openapi.options.ConfigurationException;
@@ -70,12 +70,11 @@
new TargetMap(ImmutableMap.of()),
ImmutableMap.of(),
fakeRoots,
- new WorkingSet(ImmutableList.of(), ImmutableList.of(), ImmutableList.of()),
+ new BlazeVersionData(),
workspacePathResolver,
artifactLocationDecoder,
null,
null,
- null,
null);
}
diff --git a/base/tests/integrationtests/com/google/idea/blaze/base/run/exporter/RunConfigurationSerializerTest.java b/base/tests/integrationtests/com/google/idea/blaze/base/run/exporter/RunConfigurationSerializerTest.java
new file mode 100644
index 0000000..fd5896b
--- /dev/null
+++ b/base/tests/integrationtests/com/google/idea/blaze/base/run/exporter/RunConfigurationSerializerTest.java
@@ -0,0 +1,157 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.exporter;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableMap;
+import com.google.idea.blaze.base.BlazeIntegrationTestCase;
+import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
+import com.google.idea.blaze.base.model.primitives.ExecutionRootPath;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
+import com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType;
+import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
+import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoderImpl;
+import com.google.idea.blaze.base.sync.workspace.BlazeRoots;
+import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
+import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverImpl;
+import com.intellij.execution.RunnerAndConfigurationSettings;
+import com.intellij.execution.configurations.ConfigurationType;
+import com.intellij.execution.configurations.RunConfiguration;
+import com.intellij.execution.impl.RunManagerImpl;
+import com.intellij.openapi.util.InvalidDataException;
+import org.jdom.Element;
+import org.jdom.output.Format;
+import org.jdom.output.XMLOutputter;
+import org.junit.After;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/**
+ * Test that {@link RunConfigurationSerializer} serializes/deserializes run configurations
+ * correctly.
+ */
+@RunWith(JUnit4.class)
+public class RunConfigurationSerializerTest extends BlazeIntegrationTestCase {
+
+ private RunManagerImpl runManager;
+ private BlazeCommandRunConfigurationType type;
+ private BlazeCommandRunConfiguration configuration;
+
+ @Before
+ public final void doSetup() {
+ runManager = RunManagerImpl.getInstanceImpl(getProject());
+ // Without BlazeProjectData, the configuration editor is always disabled.
+ mockBlazeProjectDataManager(getMockBlazeProjectData());
+ type = BlazeCommandRunConfigurationType.getInstance();
+
+ RunnerAndConfigurationSettings runnerAndConfigurationSettings =
+ runManager.createConfiguration("Blaze Configuration", type.getFactory());
+ runManager.addConfiguration(runnerAndConfigurationSettings, false);
+ configuration =
+ (BlazeCommandRunConfiguration) runnerAndConfigurationSettings.getConfiguration();
+ }
+
+ private BlazeProjectData getMockBlazeProjectData() {
+ BlazeRoots fakeRoots =
+ new BlazeRoots(
+ null,
+ ImmutableList.of(workspaceRoot.directory()),
+ new ExecutionRootPath("out/crosstool/bin"),
+ new ExecutionRootPath("out/crosstool/gen"),
+ null);
+ WorkspacePathResolver workspacePathResolver =
+ new WorkspacePathResolverImpl(workspaceRoot, fakeRoots);
+ ArtifactLocationDecoder artifactLocationDecoder =
+ new ArtifactLocationDecoderImpl(fakeRoots, workspacePathResolver);
+ return new BlazeProjectData(
+ 0,
+ new TargetMap(ImmutableMap.of()),
+ ImmutableMap.of(),
+ fakeRoots,
+ new BlazeVersionData(),
+ workspacePathResolver,
+ artifactLocationDecoder,
+ null,
+ null,
+ null);
+ }
+
+ @After
+ public final void doTeardown() {
+ clearRunManager();
+ }
+
+ private void clearRunManager() {
+ runManager.clearAll();
+ // We don't need to do this at setup, because it is handled by RunManagerImpl's constructor.
+ // However, clearAll() clears the configuration types, so we need to reinitialize them.
+ runManager.initializeConfigurationTypes(
+ ConfigurationType.CONFIGURATION_TYPE_EP.getExtensions());
+ }
+
+ @Test
+ public void testRunConfigurationUnalteredBySerializationRoundTrip() throws InvalidDataException {
+ configuration.setTarget(new Label("//package:rule"));
+ configuration.setKeepInSync(true);
+
+ final Element initialElement = runManager.getState();
+
+ Element element = RunConfigurationSerializer.writeToXml(configuration);
+ assertThat(RunConfigurationSerializer.findExisting(getProject(), element)).isNotNull();
+
+ clearRunManager(); // remove configuration from project
+ RunConfigurationSerializer.loadFromXmlElementIgnoreExisting(getProject(), element);
+
+ final Element newElement = runManager.getState();
+ final XMLOutputter xmlOutputter = new XMLOutputter(Format.getCompactFormat());
+ assertThat(xmlOutputter.outputString(newElement))
+ .isEqualTo(xmlOutputter.outputString(initialElement));
+ }
+
+ @Test
+ public void testSetKeepInSyncWhenImporting() throws InvalidDataException {
+ configuration.setTarget(new Label("//package:rule"));
+ configuration.setKeepInSync(false);
+
+ Element element = RunConfigurationSerializer.writeToXml(configuration);
+ assertThat(RunConfigurationSerializer.findExisting(getProject(), element)).isNotNull();
+
+ clearRunManager(); // remove configuration from project
+ RunConfigurationSerializer.loadFromXmlElementIgnoreExisting(getProject(), element);
+
+ RunConfiguration config = runManager.getAllConfigurations()[0];
+ assertThat(config).isInstanceOf(BlazeCommandRunConfiguration.class);
+ assertThat(((BlazeCommandRunConfiguration) config).getKeepInSync()).isTrue();
+ }
+
+ @Test
+ public void testKeepInSyncRespectedWhenImporting() throws InvalidDataException {
+ Element element = RunConfigurationSerializer.writeToXml(configuration);
+
+ configuration.setKeepInSync(false);
+ assertThat(RunConfigurationSerializer.shouldLoadConfiguration(getProject(), element)).isFalse();
+
+ configuration.setKeepInSync(true);
+ assertThat(RunConfigurationSerializer.shouldLoadConfiguration(getProject(), element)).isTrue();
+ }
+}
diff --git a/base/tests/unittests/com/google/idea/blaze/base/actions/BlazeBuildServiceTest.java b/base/tests/unittests/com/google/idea/blaze/base/actions/BlazeBuildServiceTest.java
new file mode 100644
index 0000000..e86bd3f
--- /dev/null
+++ b/base/tests/unittests/com/google/idea/blaze/base/actions/BlazeBuildServiceTest.java
@@ -0,0 +1,145 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.actions;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Mockito.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.eq;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableCollection;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Lists;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.model.primitives.TargetExpression;
+import com.google.idea.blaze.base.projectview.ProjectView;
+import com.google.idea.blaze.base.projectview.ProjectViewManager;
+import com.google.idea.blaze.base.projectview.ProjectViewSet;
+import com.google.idea.blaze.base.projectview.section.ListSection;
+import com.google.idea.blaze.base.projectview.section.sections.TargetSection;
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.settings.BlazeImportSettings;
+import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
+import com.google.idea.blaze.base.sync.BlazeSyncPlugin.ModuleEditor;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
+import java.io.File;
+import java.util.List;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Test cases for {@link BlazeBuildService}. */
+@RunWith(JUnit4.class)
+public class BlazeBuildServiceTest extends BlazeTestCase {
+ BlazeBuildService service;
+ ProjectViewSet viewSet;
+
+ @Override
+ protected void initTest(Container applicationServices, Container projectServices) {
+ BlazeImportSettingsManager importSettingsManager = new BlazeImportSettingsManager(project);
+ importSettingsManager.setImportSettings(
+ new BlazeImportSettings("", "", "", "", "", Blaze.BuildSystem.Blaze));
+ projectServices.register(BlazeImportSettingsManager.class, importSettingsManager);
+
+ ProjectView view =
+ ProjectView.builder()
+ .add(
+ ListSection.builder(TargetSection.KEY)
+ .add(TargetExpression.fromString("//view/target:one"))
+ .add(TargetExpression.fromString("//view/target:two")))
+ .build();
+ viewSet = ProjectViewSet.builder().add(new File("view/target/.blazeproject"), view).build();
+ ProjectViewManager viewManager = new MockProjectViewManager(viewSet);
+ projectServices.register(ProjectViewManager.class, viewManager);
+
+ projectServices.register(BlazeProjectDataManager.class, new MockProjectDataManager());
+
+ applicationServices.register(BlazeBuildService.class, spy(new BlazeBuildService()));
+
+ service = BlazeBuildService.getInstance();
+ assertThat(service).isNotNull();
+
+ // Can't mock BlazeExecutor.submitTask.
+ doNothing().when(service).buildTargetExpressions(any(), any(), any(), any(), any());
+ }
+
+ @Test
+ public void testBuildFile() {
+ ImmutableCollection<Label> labels =
+ ImmutableList.of(new Label("//foo:bar"), new Label("//foo:baz"));
+ List<TargetExpression> targets = Lists.newArrayList(labels);
+ service.buildFile(project, "Foo.java", labels);
+ verify(service).buildTargetExpressions(eq(project), eq(targets), eq(viewSet), any(), any());
+ }
+
+ @Test
+ public void testBuildProject() {
+ service.buildProject(project);
+ List<TargetExpression> targets =
+ Lists.newArrayList(
+ TargetExpression.fromString("//view/target:one"),
+ TargetExpression.fromString("//view/target:two"));
+ verify(service).buildTargetExpressions(eq(project), eq(targets), eq(viewSet), any(), any());
+ }
+
+ private static class MockProjectViewManager extends ProjectViewManager {
+ private final ProjectViewSet viewSet;
+
+ public MockProjectViewManager(ProjectViewSet viewSet) {
+ this.viewSet = viewSet;
+ }
+
+ @Nullable
+ @Override
+ public ProjectViewSet getProjectViewSet() {
+ return viewSet;
+ }
+
+ @Nullable
+ @Override
+ public ProjectViewSet reloadProjectView(
+ BlazeContext context, WorkspacePathResolver workspacePathResolver) {
+ return viewSet;
+ }
+ }
+
+ private static class MockProjectDataManager implements BlazeProjectDataManager {
+ private final BlazeProjectData projectData;
+
+ public MockProjectDataManager() {
+ this.projectData =
+ new BlazeProjectData(0L, null, null, null, null, null, null, null, null, null);
+ }
+
+ @Nullable
+ @Override
+ public BlazeProjectData getBlazeProjectData() {
+ return projectData;
+ }
+
+ @Override
+ public ModuleEditor editModules() {
+ return null;
+ }
+ }
+}
diff --git a/base/tests/unittests/com/google/idea/blaze/base/bazel/BazelVersionTest.java b/base/tests/unittests/com/google/idea/blaze/base/bazel/BazelVersionTest.java
new file mode 100644
index 0000000..5860e40
--- /dev/null
+++ b/base/tests/unittests/com/google/idea/blaze/base/bazel/BazelVersionTest.java
@@ -0,0 +1,71 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.bazel;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link BazelVersion}. */
+@RunWith(JUnit4.class)
+public class BazelVersionTest {
+
+ @Test
+ public void testParseOldVersionFormat() {
+ BazelVersion version = BazelVersion.parseVersion("release 0.4.1");
+ assertThat(version).isNotNull();
+ assertThat(version.major).isEqualTo(0);
+ assertThat(version.minor).isEqualTo(4);
+ assertThat(version.bugfix).isEqualTo(1);
+ }
+
+ @Test
+ public void testParseVersionFormatDistributionPackage() {
+ BazelVersion version = BazelVersion.parseVersion("release 0.4.3- (@non-git)");
+ assertThat(version).isNotNull();
+ assertThat(version.major).isEqualTo(0);
+ assertThat(version.minor).isEqualTo(4);
+ assertThat(version.bugfix).isEqualTo(3);
+ }
+
+ @Test
+ public void testParseVersionFormatManualBuild() {
+ BazelVersion version = BazelVersion.parseVersion("release 0.4.3- (@c9139896");
+ assertThat(version).isNotNull();
+ assertThat(version.major).isEqualTo(0);
+ assertThat(version.minor).isEqualTo(4);
+ assertThat(version.bugfix).isEqualTo(3);
+ }
+
+ @Test
+ public void testParseVersionFormatManualOld() {
+ BazelVersion version = BazelVersion.parseVersion("development version");
+ assertThat(version).isEqualTo(BazelVersion.UNKNOWN);
+ }
+
+ @Test
+ public void testIsAtLeast() {
+ BazelVersion version = BazelVersion.parseVersion("release 0.4.1");
+ assertThat(version).isNotNull();
+ assertThat(version.isAtLeast(0, 3, 2)).isTrue();
+ assertThat(version.isAtLeast(0, 4, 0)).isTrue();
+ assertThat(version.isAtLeast(0, 4, 1)).isTrue();
+ assertThat(version.isAtLeast(0, 4, 2)).isFalse();
+ assertThat(version.isAtLeast(0, 5, 0)).isFalse();
+ }
+}
diff --git a/base/tests/unittests/com/google/idea/blaze/base/projectview/ProjectViewSetTest.java b/base/tests/unittests/com/google/idea/blaze/base/projectview/ProjectViewSetTest.java
index 40ea19f..ed1fd3a 100644
--- a/base/tests/unittests/com/google/idea/blaze/base/projectview/ProjectViewSetTest.java
+++ b/base/tests/unittests/com/google/idea/blaze/base/projectview/ProjectViewSetTest.java
@@ -39,6 +39,7 @@
import com.google.idea.blaze.base.projectview.section.sections.ImportSection;
import com.google.idea.blaze.base.projectview.section.sections.ImportTargetOutputSection;
import com.google.idea.blaze.base.projectview.section.sections.MetricsProjectSection;
+import com.google.idea.blaze.base.projectview.section.sections.RunConfigurationsSection;
import com.google.idea.blaze.base.projectview.section.sections.Sections;
import com.google.idea.blaze.base.projectview.section.sections.TargetSection;
import com.google.idea.blaze.base.projectview.section.sections.TestSourceSection;
@@ -91,6 +92,9 @@
ListSection.builder(AdditionalLanguagesSection.KEY).add(LanguageClass.JAVA))
.add(ScalarSection.builder(MetricsProjectSection.KEY).set("my project"))
.add(TextBlockSection.of(TextBlock.newLine()))
+ .add(
+ ListSection.builder(RunConfigurationsSection.KEY)
+ .add(new WorkspacePath("test")))
.build())
.build();
diff --git a/base/tests/unittests/com/google/idea/blaze/base/projectview/ProjectViewVerifierTest.java b/base/tests/unittests/com/google/idea/blaze/base/projectview/ProjectViewVerifierTest.java
index 4d27c8e..fe15957 100644
--- a/base/tests/unittests/com/google/idea/blaze/base/projectview/ProjectViewVerifierTest.java
+++ b/base/tests/unittests/com/google/idea/blaze/base/projectview/ProjectViewVerifierTest.java
@@ -33,6 +33,8 @@
import com.google.idea.blaze.base.sync.BlazeSyncPlugin;
import com.google.idea.blaze.base.sync.projectview.ImportRoots;
import com.google.idea.blaze.base.sync.projectview.WorkspaceLanguageSettings;
+import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
+import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverImpl;
import java.io.File;
import java.util.Set;
import org.jetbrains.annotations.NotNull;
@@ -46,6 +48,8 @@
private static final String FAKE_ROOT = "/root";
private WorkspaceRoot workspaceRoot = new WorkspaceRoot(new File(FAKE_ROOT));
+ private WorkspacePathResolver workspacePathResolver =
+ new WorkspacePathResolverImpl(workspaceRoot);
private MockFileAttributeProvider fileAttributeProvider;
private ErrorCollector errorCollector = new ErrorCollector();
private BlazeContext context;
@@ -82,7 +86,7 @@
.build();
fileAttributeProvider.addProjectView(projectViewSet);
ProjectViewVerifier.verifyProjectView(
- context, workspaceRoot, projectViewSet, workspaceLanguageSettings);
+ context, workspacePathResolver, projectViewSet, workspaceLanguageSettings);
errorCollector.assertNoIssues();
}
@@ -104,7 +108,7 @@
.build();
fileAttributeProvider.addProjectView(projectViewSet);
ProjectViewVerifier.verifyProjectView(
- context, workspaceRoot, projectViewSet, workspaceLanguageSettings);
+ context, workspacePathResolver, projectViewSet, workspaceLanguageSettings);
errorCollector.assertIssues(
"java/com/google/android/apps/example is included, "
+ "but that contradicts java/com/google/android/apps/example which was excluded");
@@ -128,7 +132,7 @@
.build();
fileAttributeProvider.addProjectView(projectViewSet);
ProjectViewVerifier.verifyProjectView(
- context, workspaceRoot, projectViewSet, workspaceLanguageSettings);
+ context, workspacePathResolver, projectViewSet, workspaceLanguageSettings);
errorCollector.assertIssues(
"java/com/google/android/apps/example is included, "
+ "but that contradicts java/com/google/android/apps which was excluded");
@@ -153,7 +157,7 @@
.build();
fileAttributeProvider.addProjectView(projectViewSet);
ProjectViewVerifier.verifyProjectView(
- context, workspaceRoot, projectViewSet, workspaceLanguageSettings);
+ context, workspacePathResolver, projectViewSet, workspaceLanguageSettings);
errorCollector.assertNoIssues();
}
@@ -171,11 +175,33 @@
.build())
.build();
ProjectViewVerifier.verifyProjectView(
- context, workspaceRoot, projectViewSet, workspaceLanguageSettings);
+ context, workspacePathResolver, projectViewSet, workspaceLanguageSettings);
errorCollector.assertIssues(
String.format(
- "Directory '%s' specified in import roots not found under workspace root '%s'",
- "java/com/google/android/apps/example", "/root"));
+ "Directory '%s' specified in project view not found.",
+ "java/com/google/android/apps/example"));
+ }
+
+ @Test
+ public void testImportRootIsFileResultsInIssue() {
+ ProjectViewSet projectViewSet =
+ ProjectViewSet.builder()
+ .add(
+ ProjectView.builder()
+ .add(
+ ListSection.builder(DirectorySection.KEY)
+ .add(
+ DirectoryEntry.include(
+ new WorkspacePath("java/com/google/android/apps/example"))))
+ .build())
+ .build();
+ fileAttributeProvider.addFile(new WorkspacePath("java/com/google/android/apps/example"));
+ ProjectViewVerifier.verifyProjectView(
+ context, workspacePathResolver, projectViewSet, workspaceLanguageSettings);
+ errorCollector.assertIssues(
+ String.format(
+ "Directory '%s' specified in project view is a file.",
+ "java/com/google/android/apps/example"));
}
static class MockFileAttributeProvider extends FileAttributeProvider {
@@ -228,5 +254,10 @@
public boolean exists(File file) {
return files.contains(file);
}
+
+ @Override
+ public boolean isDirectory(File file) {
+ return directories.contains(file);
+ }
}
}
diff --git a/base/tests/unittests/com/google/idea/blaze/base/run/state/BlazeCommandRunConfigurationCommonStateTest.java b/base/tests/unittests/com/google/idea/blaze/base/run/state/BlazeCommandRunConfigurationCommonStateTest.java
index c8eaeec..5598b49 100644
--- a/base/tests/unittests/com/google/idea/blaze/base/run/state/BlazeCommandRunConfigurationCommonStateTest.java
+++ b/base/tests/unittests/com/google/idea/blaze/base/run/state/BlazeCommandRunConfigurationCommonStateTest.java
@@ -21,6 +21,7 @@
import com.google.common.collect.Lists;
import com.google.idea.blaze.base.BlazeTestCase;
import com.google.idea.blaze.base.command.BlazeCommandName;
+import com.google.idea.blaze.base.run.DistributedExecutorSupport;
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.settings.BlazeImportSettings;
import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
@@ -28,7 +29,6 @@
import org.jdom.Element;
import org.jdom.output.Format;
import org.jdom.output.XMLOutputter;
-import org.jetbrains.annotations.NotNull;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -43,8 +43,7 @@
private BlazeCommandRunConfigurationCommonState state;
@Override
- protected void initTest(
- @NotNull Container applicationServices, @NotNull Container projectServices) {
+ protected void initTest(Container applicationServices, Container projectServices) {
super.initTest(applicationServices, projectServices);
applicationServices.register(UISettings.class, new UISettings());
@@ -52,7 +51,9 @@
BlazeImportSettingsManager.class, new BlazeImportSettingsManager(project));
BlazeImportSettingsManager.getInstance(getProject()).setImportSettings(DUMMY_IMPORT_SETTINGS);
- state = new BlazeCommandRunConfigurationCommonState(Blaze.buildSystemName(project));
+ registerExtensionPoint(DistributedExecutorSupport.EP_NAME, DistributedExecutorSupport.class);
+
+ state = new BlazeCommandRunConfigurationCommonState(Blaze.getBuildSystem(project));
}
@Test
@@ -65,7 +66,7 @@
Element element = new Element("test");
state.writeExternal(element);
BlazeCommandRunConfigurationCommonState readState =
- new BlazeCommandRunConfigurationCommonState(Blaze.buildSystemName(project));
+ new BlazeCommandRunConfigurationCommonState(Blaze.getBuildSystem(project));
readState.readExternal(element);
assertThat(readState.getCommand()).isEqualTo(COMMAND);
@@ -79,7 +80,7 @@
Element element = new Element("test");
state.writeExternal(element);
BlazeCommandRunConfigurationCommonState readState =
- new BlazeCommandRunConfigurationCommonState(Blaze.buildSystemName(project));
+ new BlazeCommandRunConfigurationCommonState(Blaze.getBuildSystem(project));
readState.readExternal(element);
assertThat(readState.getCommand()).isEqualTo(state.getCommand());
@@ -96,7 +97,7 @@
Element element = new Element("test");
state.writeExternal(element);
BlazeCommandRunConfigurationCommonState readState =
- new BlazeCommandRunConfigurationCommonState(Blaze.buildSystemName(project));
+ new BlazeCommandRunConfigurationCommonState(Blaze.getBuildSystem(project));
readState.readExternal(element);
assertThat(readState.getBlazeFlags()).containsExactly("hi", "I'm", "Josh").inOrder();
@@ -132,7 +133,7 @@
editor.resetEditorFrom(state);
BlazeCommandRunConfigurationCommonState readState =
- new BlazeCommandRunConfigurationCommonState(Blaze.buildSystemName(project));
+ new BlazeCommandRunConfigurationCommonState(Blaze.getBuildSystem(project));
editor.applyEditorTo(readState);
assertThat(readState.getCommand()).isEqualTo(state.getCommand());
@@ -147,7 +148,7 @@
editor.resetEditorFrom(state);
BlazeCommandRunConfigurationCommonState readState =
- new BlazeCommandRunConfigurationCommonState(Blaze.buildSystemName(project));
+ new BlazeCommandRunConfigurationCommonState(Blaze.getBuildSystem(project));
editor.applyEditorTo(readState);
assertThat(readState.getCommand()).isEqualTo(state.getCommand());
diff --git a/base/tests/unittests/com/google/idea/blaze/base/run/state/RunConfigurationFlagStateTest.java b/base/tests/unittests/com/google/idea/blaze/base/run/state/RunConfigurationFlagStateTest.java
new file mode 100644
index 0000000..730ac3b
--- /dev/null
+++ b/base/tests/unittests/com/google/idea/blaze/base/run/state/RunConfigurationFlagStateTest.java
@@ -0,0 +1,75 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.run.state;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link RunConfigurationFlagsState}. */
+@RunWith(JUnit4.class)
+public class RunConfigurationFlagStateTest {
+
+ @Test
+ public void testEscapedQuotesRetainedAfterReserialization() {
+ // previously, we were removing escape chars and quotes during ParametersListUtil.parse, then
+ // not putting them back when converting back to a string.
+ ImmutableList<String> flags = ImmutableList.of("--flag=\\\"Hello_world!\\\"", "--flag2");
+ RunConfigurationFlagsState state = new RunConfigurationFlagsState("tag", "field");
+ state.setFlags(flags);
+
+ RunConfigurationStateEditor editor = state.getEditor(null);
+ editor.resetEditorFrom(state);
+ editor.applyEditorTo(state);
+
+ assertThat(state.getFlags()).isEqualTo(flags);
+ }
+
+ @Test
+ public void testQuotesRetainedAfterReserialization() {
+ ImmutableList<String> flags = ImmutableList.of("\"--flag=test\"");
+ RunConfigurationFlagsState state = new RunConfigurationFlagsState("tag", "field");
+ state.setFlags(flags);
+
+ RunConfigurationStateEditor editor = state.getEditor(null);
+ editor.resetEditorFrom(state);
+ editor.applyEditorTo(state);
+
+ assertThat(state.getFlags()).isEqualTo(flags);
+ }
+
+ @Test
+ public void testNormalFlagsAreNotMangled() {
+ ImmutableList<String> flags =
+ ImmutableList.of(
+ "--test_sharding_strategy=disabled",
+ "--test_strategy=local",
+ "--experimental_show_artifacts",
+ "--test_filter=com.google.idea.blaze.base.run.state.RunConfigurationFlagStateTest#",
+ "--define=ij_product=intellij-latest");
+ RunConfigurationFlagsState state = new RunConfigurationFlagsState("tag", "field");
+ state.setFlags(flags);
+
+ RunConfigurationStateEditor editor = state.getEditor(null);
+ editor.resetEditorFrom(state);
+ editor.applyEditorTo(state);
+
+ assertThat(state.getFlags()).isEqualTo(flags);
+ }
+}
diff --git a/base/tests/unittests/com/google/idea/blaze/base/sync/BlazeSyncManagerTest.java b/base/tests/unittests/com/google/idea/blaze/base/sync/BlazeSyncManagerTest.java
new file mode 100644
index 0000000..c8cf5ba
--- /dev/null
+++ b/base/tests/unittests/com/google/idea/blaze/base/sync/BlazeSyncManagerTest.java
@@ -0,0 +1,115 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.sync;
+
+import static com.google.common.truth.Truth.assertThat;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+
+import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.model.primitives.TargetExpression;
+import com.google.idea.blaze.base.settings.BlazeUserSettings;
+import com.google.idea.blaze.base.sync.BlazeSyncParams.SyncMode;
+import java.io.IOException;
+import java.util.List;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+import org.mockito.ArgumentCaptor;
+import org.mockito.Captor;
+import org.mockito.MockitoAnnotations;
+import org.mockito.Spy;
+
+/** Test cases for {@link BlazeSyncManager}. */
+@RunWith(JUnit4.class)
+public class BlazeSyncManagerTest extends BlazeTestCase {
+ @Spy BlazeSyncManager manager = new BlazeSyncManager(project);
+ @Captor ArgumentCaptor<BlazeSyncParams> paramsCaptor;
+
+ @Override
+ protected void initTest(Container applicationServices, Container projectServices) {
+ super.initTest(applicationServices, projectServices);
+ MockitoAnnotations.initMocks(this);
+ applicationServices.register(BlazeUserSettings.class, mock(BlazeUserSettings.class));
+ doNothing().when(manager).requestProjectSync(any());
+ projectServices.register(BlazeSyncManager.class, manager);
+ assertThat(BlazeSyncManager.getInstance(project)).isSameAs(manager);
+ }
+
+ @Test
+ public void testFullProjectSync() throws IOException {
+ manager.fullProjectSync();
+ verify(manager).requestProjectSync(paramsCaptor.capture());
+ BlazeSyncParams params = paramsCaptor.getValue();
+ assertThat(params).isNotNull();
+ assertThat(params.title).isEqualTo("Full Sync");
+ assertThat(params.syncMode).isEqualTo(SyncMode.FULL);
+ assertThat(params.backgroundSync).isFalse();
+ assertThat(params.addProjectViewTargets).isTrue();
+ assertThat(params.addWorkingSet)
+ .isEqualTo(BlazeUserSettings.getInstance().getExpandSyncToWorkingSet());
+ assertThat(params.targetExpressions).isEmpty();
+ }
+
+ @Test
+ public void testIncrementalProjectSync() throws IOException {
+ manager.incrementalProjectSync();
+ verify(manager).requestProjectSync(paramsCaptor.capture());
+ BlazeSyncParams params = paramsCaptor.getValue();
+ assertThat(params).isNotNull();
+ assertThat(params.title).isEqualTo("Sync");
+ assertThat(params.syncMode).isEqualTo(SyncMode.INCREMENTAL);
+ assertThat(params.backgroundSync).isFalse();
+ assertThat(params.addProjectViewTargets).isTrue();
+ assertThat(params.addWorkingSet)
+ .isEqualTo(BlazeUserSettings.getInstance().getExpandSyncToWorkingSet());
+ assertThat(params.targetExpressions).isEmpty();
+ }
+
+ @Test
+ public void testPartialSync() {
+ List<TargetExpression> targets =
+ ImmutableList.of(
+ TargetExpression.fromString("//foo:bar"), TargetExpression.fromString("//foo:baz"));
+ manager.partialSync(targets);
+ verify(manager).requestProjectSync(paramsCaptor.capture());
+ BlazeSyncParams params = paramsCaptor.getValue();
+ assertThat(params).isNotNull();
+ assertThat(params.title).isEqualTo("Partial Sync");
+ assertThat(params.syncMode).isEqualTo(SyncMode.PARTIAL);
+ assertThat(params.backgroundSync).isFalse();
+ assertThat(params.addProjectViewTargets).isFalse();
+ assertThat(params.addWorkingSet).isFalse();
+ assertThat(params.targetExpressions).isEqualTo(targets);
+ }
+
+ @Test
+ public void testWorkingSetSync() throws IOException {
+ manager.workingSetSync();
+ verify(manager).requestProjectSync(paramsCaptor.capture());
+ BlazeSyncParams params = paramsCaptor.getValue();
+ assertThat(params).isNotNull();
+ assertThat(params.title).isEqualTo("Sync Working Set");
+ assertThat(params.syncMode).isEqualTo(SyncMode.PARTIAL);
+ assertThat(params.backgroundSync).isFalse();
+ assertThat(params.addProjectViewTargets).isFalse();
+ assertThat(params.addWorkingSet).isTrue();
+ assertThat(params.targetExpressions).isEmpty();
+ }
+}
diff --git a/base/tests/unittests/com/google/idea/blaze/base/targetmaps/TransitiveDependencyMapTest.java b/base/tests/unittests/com/google/idea/blaze/base/targetmaps/TransitiveDependencyMapTest.java
new file mode 100644
index 0000000..3037ff1
--- /dev/null
+++ b/base/tests/unittests/com/google/idea/blaze/base/targetmaps/TransitiveDependencyMapTest.java
@@ -0,0 +1,167 @@
+/*
+ * Copyright 2016 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.idea.blaze.base.targetmaps;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
+import com.google.idea.blaze.base.ideinfo.TargetKey;
+import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.ideinfo.TargetMapBuilder;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.primitives.Label;
+import com.google.idea.blaze.base.sync.BlazeSyncPlugin.ModuleEditor;
+import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
+import javax.annotation.Nullable;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link TransitiveDependencyMap}. */
+@RunWith(JUnit4.class)
+public class TransitiveDependencyMapTest extends BlazeTestCase {
+ private TransitiveDependencyMap transitiveDependencyMap;
+
+ @Override
+ protected void initTest(Container applicationServices, Container projectServices) {
+ super.initTest(applicationServices, projectServices);
+ projectServices.register(
+ BlazeProjectDataManager.class,
+ new MockBlazeProjectDataManager(
+ new BlazeProjectData(
+ 0L, buildTargetMap(), null, null, null, null, null, null, null, null)));
+ projectServices.register(TransitiveDependencyMap.class, new TransitiveDependencyMap(project));
+ transitiveDependencyMap = TransitiveDependencyMap.getInstance(project);
+ }
+
+ @Test
+ public void testGetSimpleDependency() {
+ TargetKey simpleA = TargetKey.forPlainTarget(new Label("//com/google/example/simple:a"));
+ TargetKey simpleB = TargetKey.forPlainTarget(new Label("//com/google/example/simple:b"));
+
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(simpleA)).containsExactly(simpleB);
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(simpleB)).isEmpty();
+ }
+
+ @Test
+ public void testGetChainDependencies() {
+ TargetKey chainA = TargetKey.forPlainTarget(new Label("//com/google/example/chain:a"));
+ TargetKey chainB = TargetKey.forPlainTarget(new Label("//com/google/example/chain:b"));
+ TargetKey chainC = TargetKey.forPlainTarget(new Label("//com/google/example/chain:c"));
+ TargetKey chainD = TargetKey.forPlainTarget(new Label("//com/google/example/chain:d"));
+
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(chainA))
+ .containsExactly(chainB, chainC, chainD);
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(chainB))
+ .containsExactly(chainC, chainD);
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(chainC)).containsExactly(chainD);
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(chainD)).isEmpty();
+ }
+
+ @Test
+ public void testGetDiamondDependencies() {
+ TargetKey diamondA = TargetKey.forPlainTarget(new Label("//com/google/example/diamond:a"));
+ TargetKey diamondB = TargetKey.forPlainTarget(new Label("//com/google/example/diamond:b"));
+ TargetKey diamondBB = TargetKey.forPlainTarget(new Label("//com/google/example/diamond:bb"));
+ TargetKey diamondBBB = TargetKey.forPlainTarget(new Label("//com/google/example/diamond:bbb"));
+ TargetKey diamondC = TargetKey.forPlainTarget(new Label("//com/google/example/diamond:c"));
+ TargetKey diamondCC = TargetKey.forPlainTarget(new Label("//com/google/example/diamond:cc"));
+ TargetKey diamondCCC = TargetKey.forPlainTarget(new Label("//com/google/example/diamond:ccc"));
+
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(diamondA))
+ .containsExactly(diamondB, diamondBB, diamondBBB, diamondC, diamondCC, diamondCCC);
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(diamondB))
+ .containsExactly(diamondC);
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(diamondBB))
+ .containsExactly(diamondC, diamondCC);
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(diamondBBB))
+ .containsExactly(diamondC, diamondCC, diamondCCC);
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(diamondC)).isEmpty();
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(diamondCC)).isEmpty();
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(diamondCCC)).isEmpty();
+ }
+
+ @Test
+ public void testGetDependencyForNonExistentTarget() {
+ TargetKey bogus = TargetKey.forPlainTarget(new Label("//com/google/fake:target"));
+ assertThat(transitiveDependencyMap.getTransitiveDependencies(bogus)).isEmpty();
+ }
+
+ private static TargetMap buildTargetMap() {
+ Label simpleA = new Label("//com/google/example/simple:a");
+ Label simpleB = new Label("//com/google/example/simple:b");
+ Label chainA = new Label("//com/google/example/chain:a");
+ Label chainB = new Label("//com/google/example/chain:b");
+ Label chainC = new Label("//com/google/example/chain:c");
+ Label chainD = new Label("//com/google/example/chain:d");
+ Label diamondA = new Label("//com/google/example/diamond:a");
+ Label diamondB = new Label("//com/google/example/diamond:b");
+ Label diamondBB = new Label("//com/google/example/diamond:bb");
+ Label diamondBBB = new Label("//com/google/example/diamond:bbb");
+ Label diamondC = new Label("//com/google/example/diamond:c");
+ Label diamondCC = new Label("//com/google/example/diamond:cc");
+ Label diamondCCC = new Label("//com/google/example/diamond:ccc");
+ return TargetMapBuilder.builder()
+ .addTarget(TargetIdeInfo.builder().setLabel(simpleA).addDependency(simpleB))
+ .addTarget(TargetIdeInfo.builder().setLabel(simpleB))
+ .addTarget(TargetIdeInfo.builder().setLabel(chainA).addDependency(chainB))
+ .addTarget(TargetIdeInfo.builder().setLabel(chainB).addDependency(chainC))
+ .addTarget(TargetIdeInfo.builder().setLabel(chainC).addDependency(chainD))
+ .addTarget(TargetIdeInfo.builder().setLabel(chainD))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(diamondA)
+ .addDependency(diamondB)
+ .addDependency(diamondBB)
+ .addDependency(diamondBBB))
+ .addTarget(TargetIdeInfo.builder().setLabel(diamondB).addDependency(diamondC))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(diamondBB)
+ .addDependency(diamondC)
+ .addDependency(diamondCC))
+ .addTarget(
+ TargetIdeInfo.builder()
+ .setLabel(diamondBBB)
+ .addDependency(diamondC)
+ .addDependency(diamondCC)
+ .addDependency(diamondCCC))
+ .addTarget(TargetIdeInfo.builder().setLabel(diamondC))
+ .addTarget(TargetIdeInfo.builder().setLabel(diamondCC))
+ .addTarget(TargetIdeInfo.builder().setLabel(diamondCCC))
+ .build();
+ }
+
+ private static class MockBlazeProjectDataManager implements BlazeProjectDataManager {
+ private final BlazeProjectData blazeProjectData;
+
+ public MockBlazeProjectDataManager(BlazeProjectData blazeProjectData) {
+ this.blazeProjectData = blazeProjectData;
+ }
+
+ @Nullable
+ @Override
+ public BlazeProjectData getBlazeProjectData() {
+ return blazeProjectData;
+ }
+
+ @Override
+ public ModuleEditor editModules() {
+ return null;
+ }
+ }
+}
diff --git a/base/tests/unittests/com/google/idea/blaze/base/vcs/git/GitStatusLineProcessorTest.java b/base/tests/unittests/com/google/idea/blaze/base/vcs/git/GitStatusLineProcessorTest.java
index 06cbe96..36fbdc0 100644
--- a/base/tests/unittests/com/google/idea/blaze/base/vcs/git/GitStatusLineProcessorTest.java
+++ b/base/tests/unittests/com/google/idea/blaze/base/vcs/git/GitStatusLineProcessorTest.java
@@ -18,9 +18,11 @@
import static com.google.common.truth.Truth.assertThat;
import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.base.BlazeTestCase;
import com.google.idea.blaze.base.model.primitives.WorkspacePath;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
import java.io.File;
+import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.junit.runners.JUnit4;
@@ -28,6 +30,7 @@
/** Tests for {@link GitStatusLineProcessor} */
@RunWith(JUnit4.class)
public class GitStatusLineProcessorTest {
+ @Rule public BlazeTestCase.IgnoreOnWindowsRule rule = new BlazeTestCase.IgnoreOnWindowsRule();
@Test
public void testGitStatusParser() {
diff --git a/base/tests/utils/integration/com/google/idea/blaze/base/BlazeIntegrationTestCase.java b/base/tests/utils/integration/com/google/idea/blaze/base/BlazeIntegrationTestCase.java
index 633c9df..81d3e75 100644
--- a/base/tests/utils/integration/com/google/idea/blaze/base/BlazeIntegrationTestCase.java
+++ b/base/tests/utils/integration/com/google/idea/blaze/base/BlazeIntegrationTestCase.java
@@ -34,6 +34,7 @@
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.projectRoots.ProjectJdkTable;
+import com.intellij.openapi.util.SystemInfo;
import com.intellij.openapi.vfs.VirtualFile;
import com.intellij.testFramework.EdtTestUtil;
import com.intellij.testFramework.IdeaTestUtil;
@@ -44,6 +45,7 @@
import com.intellij.testFramework.fixtures.LightCodeInsightFixtureTestCase;
import com.intellij.testFramework.fixtures.TestFixtureBuilder;
import com.intellij.testFramework.fixtures.impl.LightTempDirTestFixtureImpl;
+import com.intellij.util.ThrowableRunnable;
import java.io.File;
import java.io.FileNotFoundException;
import javax.annotation.Nullable;
@@ -51,10 +53,32 @@
import org.junit.Before;
import org.junit.Rule;
import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
/** Base test class for blaze integration tests. {@link UsefulTestCase} */
public abstract class BlazeIntegrationTestCase {
+ /** Test rule that ensures tests do not run on Windows (see http://b.android.com/222904) */
+ public static class IgnoreOnWindowsRule implements TestRule {
+ @Override
+ public Statement apply(Statement base, Description description) {
+ if (SystemInfo.isWindows) {
+ return new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ System.out.println(
+ "Test \""
+ + description.getDisplayName()
+ + "\" does not run on Windows (see http://b.android.com/222904)");
+ }
+ };
+ }
+ return base;
+ }
+ }
+
+ @Rule public final IgnoreOnWindowsRule rule = new IgnoreOnWindowsRule();
@Rule public final IntellijTestSetupRule setupRule = new IntellijTestSetupRule();
@Rule public final TestRule testRunWrapper = runTestsOnEdt() ? new EdtRule() : null;
@@ -74,20 +98,20 @@
testFixture.setUp();
fileSystem = new TestFileSystem(getProject(), testFixture.getTempDirFixture());
- Runnable writeAction =
- () ->
- ApplicationManager.getApplication()
- .runWriteAction(
- () -> {
- ProjectJdkTable.getInstance().addJdk(IdeaTestUtil.getMockJdk18());
- VirtualFile workspaceRootVirtualFile =
- fileSystem.createDirectory("workspace");
- workspaceRoot =
- new WorkspaceRoot(new File(workspaceRootVirtualFile.getPath()));
- projectDataDirectory = fileSystem.createDirectory("project-data-dir");
- workspace = new WorkspaceFileSystem(workspaceRoot, fileSystem);
- });
- EdtTestUtil.runInEdtAndWait(writeAction);
+ EdtTestUtil.runInEdtAndWait(
+ (ThrowableRunnable<Throwable>)
+ () ->
+ ApplicationManager.getApplication()
+ .runWriteAction(
+ () -> {
+ ProjectJdkTable.getInstance().addJdk(IdeaTestUtil.getMockJdk18());
+ VirtualFile workspaceRootVirtualFile =
+ fileSystem.createDirectory("workspace");
+ workspaceRoot =
+ new WorkspaceRoot(new File(workspaceRootVirtualFile.getPath()));
+ projectDataDirectory = fileSystem.createDirectory("project-data-dir");
+ workspace = new WorkspaceFileSystem(workspaceRoot, fileSystem);
+ }));
BlazeImportSettingsManager.getInstance(getProject())
.setImportSettings(
diff --git a/base/tests/utils/integration/com/google/idea/blaze/base/EditorTestHelper.java b/base/tests/utils/integration/com/google/idea/blaze/base/EditorTestHelper.java
index e7a2d4e..b4dede2 100644
--- a/base/tests/utils/integration/com/google/idea/blaze/base/EditorTestHelper.java
+++ b/base/tests/utils/integration/com/google/idea/blaze/base/EditorTestHelper.java
@@ -36,6 +36,7 @@
import com.intellij.testFramework.EditorTestUtil.CaretInfo;
import com.intellij.testFramework.EdtTestUtil;
import com.intellij.testFramework.fixtures.CodeInsightTestFixture;
+import com.intellij.util.ThrowableRunnable;
import java.util.Arrays;
import javax.annotation.Nullable;
@@ -54,7 +55,8 @@
}
public Editor openFileInEditor(VirtualFile file) {
- EdtTestUtil.runInEdtAndWait((Runnable) () -> testFixture.openFileInEditor(file));
+ EdtTestUtil.runInEdtAndWait(
+ (ThrowableRunnable<Throwable>) () -> testFixture.openFileInEditor(file));
return testFixture.getEditor();
}
@@ -125,7 +127,7 @@
public void setCaretPosition(Editor editor, int lineNumber, int columnNumber) {
final CaretInfo info = new CaretInfo(new LogicalPosition(lineNumber, columnNumber), null);
EdtTestUtil.runInEdtAndWait(
- (Runnable)
+ (ThrowableRunnable<Throwable>)
() ->
EditorTestUtil.setCaretsAndSelection(
editor, new CaretAndSelectionState(ImmutableList.of(info), null)));
diff --git a/base/tests/utils/integration/com/google/idea/blaze/base/lang/buildfile/BuildFileIntegrationTestCase.java b/base/tests/utils/integration/com/google/idea/blaze/base/lang/buildfile/BuildFileIntegrationTestCase.java
index efa81a8..78d1ec3 100644
--- a/base/tests/utils/integration/com/google/idea/blaze/base/lang/buildfile/BuildFileIntegrationTestCase.java
+++ b/base/tests/utils/integration/com/google/idea/blaze/base/lang/buildfile/BuildFileIntegrationTestCase.java
@@ -25,12 +25,13 @@
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.lang.buildfile.psi.BuildFile;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
+import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.ExecutionRootPath;
import com.google.idea.blaze.base.model.primitives.WorkspacePath;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoder;
import com.google.idea.blaze.base.sync.workspace.ArtifactLocationDecoderImpl;
import com.google.idea.blaze.base.sync.workspace.BlazeRoots;
-import com.google.idea.blaze.base.sync.workspace.WorkingSet;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverImpl;
import com.intellij.openapi.vfs.VirtualFile;
@@ -83,12 +84,11 @@
new TargetMap(ImmutableMap.of()),
ImmutableMap.of(),
fakeRoots,
- new WorkingSet(ImmutableList.of(), ImmutableList.of(), ImmutableList.of()),
+ new BlazeVersionData(),
workspacePathResolver,
artifactLocationDecoder,
null,
- null,
- null,
+ new SyncState.Builder().build(),
null);
}
}
diff --git a/base/tests/utils/integration/com/google/idea/blaze/base/sync/BlazeSyncIntegrationTestCase.java b/base/tests/utils/integration/com/google/idea/blaze/base/sync/BlazeSyncIntegrationTestCase.java
index b197413..a0ac661 100644
--- a/base/tests/utils/integration/com/google/idea/blaze/base/sync/BlazeSyncIntegrationTestCase.java
+++ b/base/tests/utils/integration/com/google/idea/blaze/base/sync/BlazeSyncIntegrationTestCase.java
@@ -29,6 +29,7 @@
import com.google.idea.blaze.base.command.info.BlazeInfo;
import com.google.idea.blaze.base.ideinfo.ArtifactLocation;
import com.google.idea.blaze.base.ideinfo.TargetMap;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.TargetExpression;
import com.google.idea.blaze.base.model.primitives.WorkspacePath;
@@ -53,6 +54,7 @@
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolver;
import com.google.idea.blaze.base.sync.workspace.WorkspacePathResolverImpl;
import com.google.idea.blaze.base.vcs.BlazeVcsHandler;
+import com.intellij.ide.IdeEventQueue;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.ContentEntry;
import com.intellij.openapi.roots.ModifiableRootModel;
@@ -60,6 +62,8 @@
import com.intellij.openapi.vfs.VirtualFile;
import java.util.List;
import java.util.Map;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
import javax.annotation.Nullable;
import org.junit.Before;
@@ -182,7 +186,20 @@
project,
BlazeImportSettingsManager.getInstance(project).getImportSettings(),
syncParams);
- syncTask.syncProject(context);
+
+ // We need to run sync off EDT to keep IntelliJ's transaction system happy
+ // Because the sync task itself wants to run occasional EDT tasks, we'll have
+ // to keep flushing the event queue.
+ Future<?> future =
+ Executors.newSingleThreadExecutor().submit(() -> syncTask.syncProject(context));
+ while (!future.isDone()) {
+ IdeEventQueue.getInstance().flushQueue();
+ try {
+ Thread.sleep(50);
+ } catch (InterruptedException e) {
+ e.printStackTrace();
+ }
+ }
}
private static class MockProjectViewManager extends ProjectViewManager {
@@ -282,6 +299,7 @@
BlazeContext context,
WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
List<TargetExpression> targets,
WorkspaceLanguageSettings workspaceLanguageSettings,
ArtifactLocationDecoder artifactLocationDecoder,
@@ -297,6 +315,18 @@
BlazeContext context,
WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
+ List<TargetExpression> targets) {
+ return BuildResult.SUCCESS;
+ }
+
+ @Override
+ public BuildResult compileIdeArtifacts(
+ Project project,
+ BlazeContext context,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
List<TargetExpression> targets) {
return BuildResult.SUCCESS;
}
diff --git a/base/tests/utils/unit/com/google/idea/blaze/base/BlazeTestCase.java b/base/tests/utils/unit/com/google/idea/blaze/base/BlazeTestCase.java
index 428b180..874fd28 100644
--- a/base/tests/utils/unit/com/google/idea/blaze/base/BlazeTestCase.java
+++ b/base/tests/utils/unit/com/google/idea/blaze/base/BlazeTestCase.java
@@ -19,17 +19,22 @@
import com.intellij.openapi.Disposable;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.extensions.DefaultPluginDescriptor;
-import com.intellij.openapi.extensions.ExtensionPoint;
import com.intellij.openapi.extensions.ExtensionPointName;
import com.intellij.openapi.extensions.Extensions;
+import com.intellij.openapi.extensions.PluginDescriptor;
import com.intellij.openapi.extensions.PluginId;
import com.intellij.openapi.extensions.impl.ExtensionPointImpl;
import com.intellij.openapi.extensions.impl.ExtensionsAreaImpl;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.util.Disposer;
+import com.intellij.openapi.util.SystemInfo;
import org.jetbrains.annotations.NotNull;
import org.junit.After;
import org.junit.Before;
+import org.junit.Rule;
+import org.junit.rules.TestRule;
+import org.junit.runner.Description;
+import org.junit.runners.model.Statement;
import org.picocontainer.MutablePicoContainer;
/**
@@ -40,6 +45,27 @@
* <p>Provides a mock application and a mock project.
*/
public class BlazeTestCase {
+ /** Test rule that ensures tests do not run on Windows (see http://b.android.com/222904) */
+ public static class IgnoreOnWindowsRule implements TestRule {
+ @NotNull
+ @Override
+ public Statement apply(Statement base, Description description) {
+ if (SystemInfo.isWindows) {
+ return new Statement() {
+ @Override
+ public void evaluate() throws Throwable {
+ System.out.println(
+ "Test \""
+ + description.getDisplayName()
+ + "\" does not run on Windows (see http://b.android.com/222904)");
+ }
+ };
+ }
+ return base;
+ }
+ }
+
+ @Rule public IgnoreOnWindowsRule rule = new IgnoreOnWindowsRule();
protected Project project;
private ExtensionsAreaImpl extensionsArea;
@@ -94,16 +120,9 @@
protected <T> ExtensionPointImpl<T> registerExtensionPoint(
@NotNull ExtensionPointName<T> name, @NotNull Class<T> type) {
- ExtensionPointImpl<T> extensionPoint =
- new ExtensionPointImpl<T>(
- name.getName(),
- type.getName(),
- ExtensionPoint.Kind.INTERFACE,
- extensionsArea,
- null,
- new Extensions.SimpleLogProvider(),
- new DefaultPluginDescriptor(PluginId.getId(type.getName()), type.getClassLoader()));
- extensionsArea.registerExtensionPoint(extensionPoint);
- return extensionPoint;
+ PluginDescriptor pluginDescriptor =
+ new DefaultPluginDescriptor(PluginId.getId(type.getName()), type.getClassLoader());
+ extensionsArea.registerExtensionPoint(name.getName(), type.getName(), pluginDescriptor);
+ return extensionsArea.getExtensionPoint(name.getName());
}
}
diff --git a/base/tests/utils/unit/com/google/idea/blaze/base/run/MockBlazeCommandRunConfigurationHandlerProvider.java b/base/tests/utils/unit/com/google/idea/blaze/base/run/MockBlazeCommandRunConfigurationHandlerProvider.java
index 4f30237..c4b6762 100644
--- a/base/tests/utils/unit/com/google/idea/blaze/base/run/MockBlazeCommandRunConfigurationHandlerProvider.java
+++ b/base/tests/utils/unit/com/google/idea/blaze/base/run/MockBlazeCommandRunConfigurationHandlerProvider.java
@@ -81,6 +81,9 @@
public JComponent createComponent() {
return null;
}
+
+ @Override
+ public void setComponentEnabled(boolean enabled) {}
};
}
}
diff --git a/build_defs/build_defs.bzl b/build_defs/build_defs.bzl
index f836204..3104e0f 100644
--- a/build_defs/build_defs.bzl
+++ b/build_defs/build_defs.bzl
@@ -191,22 +191,16 @@
"chmod +w $@",
"mkdir -p META-INF",
"cp $(location {plugin_xml}) META-INF/plugin.xml".format(plugin_xml=plugin_xml),
- "$(location {zip_tool}) -u $@ META-INF/plugin.xml >/dev/null".format(zip_tool=zip_tool),
]
- srcs = [
+ srcs = meta_inf_files + [
plugin_xml,
deploy_jar,
]
for meta_inf_file in meta_inf_files:
- cmd.append("cp $(location {meta_inf_file}) META-INF/$$(basename $(location {meta_inf_file}))".format(
- meta_inf_file=meta_inf_file,
- ))
- cmd.append("$(location {zip_tool}) -u $@ META-INF/$$(basename $(location {meta_inf_file})) >/dev/null".format(
- zip_tool=zip_tool,
- meta_inf_file=meta_inf_file,
- ))
- srcs.append(meta_inf_file)
+ cmd.append("meta_inf_files='$(locations {meta_inf_file})'".format(meta_inf_file=meta_inf_file))
+ cmd.append("for f in $$meta_inf_files; do cp $$f META-INF/; done")
+ cmd.append("$(location {zip_tool}) -u $@ META-INF/* >/dev/null".format(zip_tool=zip_tool))
native.genrule(
name = name + "_genrule",
@@ -236,28 +230,38 @@
tags = ["intellij-plugin-bundle"],
)
-def repackage_jar(name, src_rule, out,
- rules = [
- "com.google.common.** com.google.repackaged.common.@1",
- "com.google.gson.** com.google.repackaged.gson.@1",
- "com.google.protobuf.** com.google.repackaged.protobuf.@1",
- "com.google.thirdparty.** com.google.repackaged.thirdparty.@1",
- ], **kwargs):
+def repackaged_jar(name, deps, rules, launcher=None, **kwargs):
"""Repackages classes in a jar, to avoid collisions in the classpath.
Args:
name: the name of this target
- src_rule: a java_binary label with the create_executable attribute set to 0
- out: the output jarfile
+ deps: The dependencies repackage
rules: the rules to apply in the repackaging
- Only repackage some of com.google.** from proto_deps.jar.
- We do not repackage:
+ Do not repackage:
- com.google.net.** because that has JNI files which use
FindClass(JNIEnv *, const char *) with hard-coded native string
literals that jarjar doesn't rewrite.
- com.google.errorprone packages (rewriting will throw off blaze build).
+ launcher: The launcher arg to pass to java_binary
**kwargs: Any additional arguments to pass to the final target.
"""
+ java_binary_name = name + "_deploy_jar"
+ out = name + ".jar"
+ native.java_binary(
+ name = java_binary_name,
+ create_executable = 0,
+ stamp = 0,
+ launcher = launcher,
+ runtime_deps = deps,
+ )
+ _repackage_jar(name, java_binary_name, out, rules, **kwargs)
+
+def repackage_jar(name, src_rule, out, rules, **kwargs):
+ print("repackage_jar is deprecated. Please switch to repackaged_jar.")
+ _repackage_jar(name, src_rule, out, rules, **kwargs)
+
+def _repackage_jar(name, src_rule, out, rules, **kwargs):
+ """Repackages classes in a jar, to avoid collisions in the classpath."""
repackage_tool = "@jarjar//jar"
deploy_jar = "{src_rule}_deploy.jar".format(src_rule=src_rule)
script_lines = []
diff --git a/clwb/src/com/google/idea/blaze/clwb/run/BlazeCidrRunConfigurationHandler.java b/clwb/src/com/google/idea/blaze/clwb/run/BlazeCidrRunConfigurationHandler.java
index 29aea18..c5ded30 100644
--- a/clwb/src/com/google/idea/blaze/clwb/run/BlazeCidrRunConfigurationHandler.java
+++ b/clwb/src/com/google/idea/blaze/clwb/run/BlazeCidrRunConfigurationHandler.java
@@ -23,6 +23,7 @@
import com.google.idea.blaze.base.run.confighandler.BlazeCommandRunConfigurationRunner;
import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.intellij.execution.Executor;
import com.intellij.execution.RunnerAndConfigurationSettings;
import com.intellij.execution.configurations.RunConfiguration;
@@ -38,8 +39,9 @@
private final BlazeCommandRunConfigurationCommonState state;
public BlazeCidrRunConfigurationHandler(BlazeCommandRunConfiguration configuration) {
- this.buildSystemName = Blaze.buildSystemName(configuration.getProject());
- this.state = new BlazeCommandRunConfigurationCommonState(buildSystemName);
+ BuildSystem buildSystem = Blaze.getBuildSystem(configuration.getProject());
+ this.buildSystemName = buildSystem.getName();
+ this.state = new BlazeCommandRunConfigurationCommonState(buildSystem);
}
@Override
diff --git a/common/actionhelper/BUILD b/common/actionhelper/BUILD
new file mode 100644
index 0000000..0da6dd5
--- /dev/null
+++ b/common/actionhelper/BUILD
@@ -0,0 +1,11 @@
+licenses(["notice"]) # Apache 2.0
+
+java_library(
+ name = "actionhelper",
+ srcs = glob(["src/**/*.java"]),
+ visibility = ["//visibility:public"],
+ deps = [
+ "//intellij_platform_sdk:plugin_api",
+ "@jsr305_annotations//jar",
+ ],
+)
diff --git a/common/actionhelper/src/com/google/idea/common/actionhelper/ActionPresentationHelper.java b/common/actionhelper/src/com/google/idea/common/actionhelper/ActionPresentationHelper.java
new file mode 100644
index 0000000..96a7882
--- /dev/null
+++ b/common/actionhelper/src/com/google/idea/common/actionhelper/ActionPresentationHelper.java
@@ -0,0 +1,175 @@
+/*
+ * Copyright 2016 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.idea.common.actionhelper;
+
+import com.intellij.openapi.actionSystem.AnActionEvent;
+import com.intellij.openapi.actionSystem.Presentation;
+import com.intellij.openapi.vfs.VirtualFile;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/** Helps setting the presentation enabled/visible/text states. */
+public class ActionPresentationHelper {
+
+ private final Presentation presentation;
+ private boolean enabled = true;
+ private boolean visible = true;
+ private boolean disableWithoutSubject;
+ private boolean hasSubject;
+ private String text;
+ private String subjectText;
+
+ /** Converts a subject to a string */
+ @FunctionalInterface
+ public interface SubjectToString<T> {
+ String subjectToString(T subject);
+ }
+
+ private ActionPresentationHelper(Presentation presentation) {
+ this.presentation = presentation;
+ }
+
+ public static ActionPresentationHelper of(AnActionEvent e) {
+ return new ActionPresentationHelper(e.getPresentation());
+ }
+
+ /** Disables the action if the condition is true. */
+ public ActionPresentationHelper disableIf(boolean disableCondition) {
+ this.enabled = this.enabled && !disableCondition;
+ return this;
+ }
+
+ /** Hides the action if the condition is true. */
+ public ActionPresentationHelper hideIf(boolean hideCondition) {
+ this.visible = this.visible && !hideCondition;
+ return this;
+ }
+
+ /** Disables the action if no subject has been provided. */
+ public ActionPresentationHelper disableWithoutSubject() {
+ this.disableWithoutSubject = true;
+ return this;
+ }
+
+ /** Sets the text of the presentation. */
+ public ActionPresentationHelper setText(String text) {
+ this.text = text;
+ return this;
+ }
+
+ /**
+ * Sets the text depending on the subject.
+ *
+ * @param noSubjectText Text to set if there is no subject, or if the action is disabled.
+ * @param subjectText Text to set if there is a subject. If %s exists in the subject text,
+ * String.format is used with the quoted file name.
+ * @param file The subject. May be null.
+ */
+ public ActionPresentationHelper setTextWithSubject(
+ String noSubjectText, String subjectText, @Nullable VirtualFile file) {
+ return setTextWithSubject(
+ noSubjectText, subjectText, file, ActionPresentationHelper::quoteFileName);
+ }
+
+ /**
+ * Sets the text depending on the subject.
+ *
+ * @param noSubjectText Text to set if there is no subject, or if the action is disabled.
+ * @param subjectText Text to set if there is a subject. If %s exists in the subject text,
+ * String.format is used with the subject passed through subjectToString
+ * @param subject The subject. May be null.
+ * @param subjectToString Method used to convert the subject to a string.
+ */
+ public <T> ActionPresentationHelper setTextWithSubject(
+ String noSubjectText,
+ String subjectText,
+ @Nullable T subject,
+ SubjectToString<T> subjectToString) {
+ this.text = noSubjectText;
+ if (subject != null) {
+ this.subjectText =
+ subjectText.contains("%s")
+ ? String.format(subjectText, subjectToString.subjectToString(subject))
+ : subjectText;
+ this.hasSubject = true;
+ }
+ return this;
+ }
+
+ /**
+ * Sets the text depending on the subjects.
+ *
+ * @param noSubjectText Text to set if there is no subject, or if the action is disabled.
+ * @param singleSubjectText Text to set if there is a single subject. If %s exists in the subject
+ * text, String.format is used with the quoted single file name.
+ * @param multipleSubjectText Text to use if there are multiple subjects.
+ */
+ public ActionPresentationHelper setTextWithSubjects(
+ String noSubjectText,
+ String singleSubjectText,
+ String multipleSubjectText,
+ List<VirtualFile> files) {
+ return setTextWithSubjects(
+ noSubjectText,
+ singleSubjectText,
+ multipleSubjectText,
+ files,
+ ActionPresentationHelper::quoteFileName);
+ }
+
+ /**
+ * Sets the text depending on the subjects.
+ *
+ * @param noSubjectText Text to set if there is no subject, or if the action is disabled.
+ * @param singleSubjectText Text to set if there is a single subject. If %s exists in the subject
+ * text, String.format is used with the subject passed through subjectToString.
+ * @param multipleSubjectText Text to use if there are multiple subjects.
+ */
+ public <T> ActionPresentationHelper setTextWithSubjects(
+ String noSubjectText,
+ String singleSubjectText,
+ String multipleSubjectText,
+ List<T> subjects,
+ SubjectToString<T> subjectToString) {
+ if (subjects.size() > 1) {
+ this.text = noSubjectText;
+ this.subjectText = multipleSubjectText;
+ this.hasSubject = true;
+ return this;
+ } else {
+ T subject = !subjects.isEmpty() ? subjects.get(0) : null;
+ return setTextWithSubject(noSubjectText, singleSubjectText, subject, subjectToString);
+ }
+ }
+
+ private static String quoteFileName(VirtualFile file) {
+ return "\"" + file.getName() + "\"";
+ }
+
+ public void commit() {
+ boolean enabled = this.enabled;
+ if (disableWithoutSubject) {
+ enabled = enabled && hasSubject;
+ }
+ presentation.setEnabled(enabled);
+ presentation.setVisible(visible);
+
+ String text = enabled && hasSubject ? subjectText : this.text;
+ if (text != null) {
+ presentation.setText(text);
+ }
+ }
+}
diff --git a/common/formatter/BUILD b/common/formatter/BUILD
index 839a469..1e45774 100644
--- a/common/formatter/BUILD
+++ b/common/formatter/BUILD
@@ -6,6 +6,7 @@
visibility = ["//visibility:public"],
deps = [
"//intellij_platform_sdk:plugin_api",
+ "//sdkcompat",
"@jsr305_annotations//jar",
],
)
diff --git a/common/formatter/src/com/google/idea/common/formatter/DelegatingCodeStyleManager.java b/common/formatter/src/com/google/idea/common/formatter/DelegatingCodeStyleManager.java
index aa2460f..354fea4 100644
--- a/common/formatter/src/com/google/idea/common/formatter/DelegatingCodeStyleManager.java
+++ b/common/formatter/src/com/google/idea/common/formatter/DelegatingCodeStyleManager.java
@@ -15,6 +15,7 @@
*/
package com.google.idea.common.formatter;
+import com.google.idea.sdkcompat.codestyle.CodeStyleManagerSdkCompatAdapter;
import com.intellij.lang.ASTNode;
import com.intellij.openapi.editor.Document;
import com.intellij.openapi.fileTypes.FileType;
@@ -31,7 +32,7 @@
import javax.annotation.Nullable;
/** A delegating {@link CodeStyleManager}. */
-public abstract class DelegatingCodeStyleManager extends CodeStyleManager {
+public abstract class DelegatingCodeStyleManager extends CodeStyleManagerSdkCompatAdapter {
private final CodeStyleManager delegate;
diff --git a/cpp/src/com/google/idea/blaze/cpp/BlazeCSyncPlugin.java b/cpp/src/com/google/idea/blaze/cpp/BlazeCSyncPlugin.java
index c066fc4..1c64fbc 100644
--- a/cpp/src/com/google/idea/blaze/cpp/BlazeCSyncPlugin.java
+++ b/cpp/src/com/google/idea/blaze/cpp/BlazeCSyncPlugin.java
@@ -27,11 +27,9 @@
import com.google.idea.blaze.base.sync.BlazeSyncPlugin;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.project.Project;
-import com.intellij.openapi.roots.ModifiableRootModel;
import com.jetbrains.cidr.lang.workspace.OCWorkspace;
import com.jetbrains.cidr.lang.workspace.OCWorkspaceManager;
import java.util.Set;
-import javax.annotation.Nullable;
final class BlazeCSyncPlugin extends BlazeSyncPlugin.Adapter {
@Override
@@ -43,16 +41,13 @@
}
@Override
- public void updateProjectStructure(
+ public void updateInMemoryState(
Project project,
BlazeContext context,
WorkspaceRoot workspaceRoot,
ProjectViewSet projectViewSet,
BlazeProjectData blazeProjectData,
- @Nullable BlazeProjectData oldBlazeProjectData,
- ModuleEditor moduleEditor,
- Module workspaceModule,
- ModifiableRootModel workspaceModifiableModel) {
+ Module workspaceModule) {
if (!blazeProjectData.workspaceLanguageSettings.isLanguageActive(LanguageClass.C)) {
return;
}
diff --git a/golang/BUILD b/golang/BUILD
new file mode 100644
index 0000000..16a486c
--- /dev/null
+++ b/golang/BUILD
@@ -0,0 +1,38 @@
+licenses(["notice"]) # Apache 2.0
+
+java_library(
+ name = "golang",
+ srcs = glob(["src/**/*.java"]),
+ visibility = ["//visibility:public"],
+ deps = [
+ "//base",
+ "//intellij_platform_sdk:plugin_api",
+ "//sdkcompat",
+ "@jsr305_annotations//jar",
+ ],
+)
+
+filegroup(
+ name = "plugin_xml",
+ srcs = ["src/META-INF/golang.xml"],
+ visibility = ["//visibility:public"],
+)
+
+load(
+ "//testing:test_defs.bzl",
+ "intellij_unit_test_suite",
+)
+
+intellij_unit_test_suite(
+ name = "unit_tests",
+ srcs = glob(["tests/unittests/**/*.java"]),
+ test_package_root = "com.google.idea.blaze.golang",
+ deps = [
+ ":golang",
+ "//base",
+ "//base:unit_test_utils",
+ "//intellij_platform_sdk:plugin_api_for_tests",
+ "@jsr305_annotations//jar",
+ "@junit//jar",
+ ],
+)
diff --git a/golang/src/META-INF/golang.xml b/golang/src/META-INF/golang.xml
new file mode 100644
index 0000000..32948ee
--- /dev/null
+++ b/golang/src/META-INF/golang.xml
@@ -0,0 +1,7 @@
+<idea-plugin>
+
+ <extensions defaultExtensionNs="com.google.idea.blaze">
+ <SyncPlugin implementation="com.google.idea.blaze.golang.sync.BlazeGoSyncPlugin"/>
+ </extensions>
+
+</idea-plugin>
diff --git a/golang/src/com/google/idea/blaze/golang/sdk/GoSdkUtil.java b/golang/src/com/google/idea/blaze/golang/sdk/GoSdkUtil.java
new file mode 100644
index 0000000..ba42571
--- /dev/null
+++ b/golang/src/com/google/idea/blaze/golang/sdk/GoSdkUtil.java
@@ -0,0 +1,59 @@
+/*
+ * Copyright 2016 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.idea.blaze.golang.sdk;
+
+import com.intellij.execution.configurations.PathEnvironmentVariableUtil;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.openapi.vfs.LocalFileSystem;
+import com.intellij.openapi.vfs.VirtualFile;
+import java.io.File;
+import java.io.IOException;
+import javax.annotation.Nullable;
+
+/**
+ * Go-lang SDK utility methods.
+ *
+ * <p>TODO: Remove this, and reference go-lang plugin source code directly.
+ */
+public class GoSdkUtil {
+
+ @Nullable
+ public static VirtualFile suggestSdkDirectory() {
+ String fromEnv = suggestSdkDirectoryPathFromEnv();
+ if (fromEnv != null) {
+ return LocalFileSystem.getInstance().findFileByPath(fromEnv);
+ }
+ return LocalFileSystem.getInstance().findFileByPath("/usr/local/go");
+ }
+
+ @Nullable
+ private static String suggestSdkDirectoryPathFromEnv() {
+ File fileFromPath = PathEnvironmentVariableUtil.findInPath("go");
+ if (fileFromPath != null) {
+ File canonicalFile;
+ try {
+ canonicalFile = fileFromPath.getCanonicalFile();
+ String path = canonicalFile.getPath();
+ if (path.endsWith("bin/go")) {
+ return StringUtil.trimEnd(path, "bin/go");
+ }
+ } catch (IOException e) {
+ // if it can't be found, just silently return null
+ }
+ }
+ return null;
+ }
+}
diff --git a/golang/src/com/google/idea/blaze/golang/sync/BlazeGoLibrarySource.java b/golang/src/com/google/idea/blaze/golang/sync/BlazeGoLibrarySource.java
new file mode 100644
index 0000000..693c5f7
--- /dev/null
+++ b/golang/src/com/google/idea/blaze/golang/sync/BlazeGoLibrarySource.java
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2016 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.idea.blaze.golang.sync;
+
+import com.google.idea.blaze.base.sync.libraries.LibrarySource;
+import com.intellij.openapi.roots.libraries.Library;
+import java.util.function.Predicate;
+
+/** Prevents garbage collection of Go libraries */
+class BlazeGoLibrarySource extends LibrarySource.Adapter {
+
+ static final BlazeGoLibrarySource INSTANCE = new BlazeGoLibrarySource();
+
+ private BlazeGoLibrarySource() {}
+
+ @Override
+ public Predicate<Library> getGcRetentionFilter() {
+ return BlazeGoLibrarySource::isGoLibrary;
+ }
+
+ static boolean isGoLibrary(Library library) {
+ String name = library.getName();
+ return name != null && name.startsWith(BlazeGoSyncPlugin.GO_LIBRARY_PREFIX);
+ }
+}
diff --git a/golang/src/com/google/idea/blaze/golang/sync/BlazeGoSyncPlugin.java b/golang/src/com/google/idea/blaze/golang/sync/BlazeGoSyncPlugin.java
new file mode 100644
index 0000000..7f2a5c7
--- /dev/null
+++ b/golang/src/com/google/idea/blaze/golang/sync/BlazeGoSyncPlugin.java
@@ -0,0 +1,243 @@
+/*
+ * Copyright 2016 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.idea.blaze.golang.sync;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.common.collect.Lists;
+import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
+import com.google.idea.blaze.base.model.primitives.LanguageClass;
+import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
+import com.google.idea.blaze.base.model.primitives.WorkspaceType;
+import com.google.idea.blaze.base.projectview.ProjectViewSet;
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.scope.output.IssueOutput;
+import com.google.idea.blaze.base.sync.BlazeSyncPlugin;
+import com.google.idea.blaze.base.sync.GenericSourceFolderProvider;
+import com.google.idea.blaze.base.sync.SourceFolderProvider;
+import com.google.idea.blaze.base.sync.data.BlazeDataStorage;
+import com.google.idea.blaze.base.sync.libraries.LibrarySource;
+import com.google.idea.blaze.base.sync.projectview.WorkspaceLanguageSettings;
+import com.google.idea.blaze.golang.sdk.GoSdkUtil;
+import com.google.idea.sdkcompat.transactions.Transactions;
+import com.intellij.ide.plugins.IdeaPluginDescriptor;
+import com.intellij.ide.plugins.PluginManager;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.extensions.PluginId;
+import com.intellij.openapi.module.Module;
+import com.intellij.openapi.module.ModuleType;
+import com.intellij.openapi.module.ModuleTypeManager;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.projectRoots.ProjectJdkTable;
+import com.intellij.openapi.projectRoots.Sdk;
+import com.intellij.openapi.projectRoots.SdkType;
+import com.intellij.openapi.projectRoots.SdkTypeId;
+import com.intellij.openapi.projectRoots.impl.SdkConfigurationUtil;
+import com.intellij.openapi.roots.ModifiableRootModel;
+import com.intellij.openapi.roots.ProjectRootManager;
+import com.intellij.openapi.roots.libraries.Library;
+import com.intellij.openapi.roots.libraries.LibraryTablesRegistrar;
+import com.intellij.openapi.updateSettings.impl.pluginsAdvertisement.PluginsAdvertiser;
+import com.intellij.openapi.util.EmptyRunnable;
+import com.intellij.openapi.vfs.VirtualFile;
+import com.intellij.pom.NavigatableAdapter;
+import java.util.List;
+import java.util.Set;
+import javax.annotation.Nullable;
+
+/** Supports golang. */
+public class BlazeGoSyncPlugin extends BlazeSyncPlugin.Adapter {
+
+ static final String GO_LIBRARY_PREFIX = "GOPATH";
+ private static final String GO_MODULE_TYPE_ID = "GO_MODULE";
+ private static final String GO_PLUGIN_ID = "ro.redeul.google.go";
+ private static final String GO_SDK_TYPE_ID = "Go SDK";
+
+ @Nullable
+ @Override
+ public ModuleType<?> getWorkspaceModuleType(WorkspaceType workspaceType) {
+ if (workspaceType == WorkspaceType.GO) {
+ return ModuleTypeManager.getInstance().findByID(GO_MODULE_TYPE_ID);
+ }
+ return null;
+ }
+
+ @Override
+ public ImmutableList<WorkspaceType> getSupportedWorkspaceTypes() {
+ return ImmutableList.of(WorkspaceType.GO);
+ }
+
+ @Override
+ public Set<LanguageClass> getSupportedLanguagesInWorkspace(WorkspaceType workspaceType) {
+ if (workspaceType == WorkspaceType.GO) {
+ return ImmutableSet.of(LanguageClass.GO);
+ }
+ return ImmutableSet.of();
+ }
+
+ @Nullable
+ @Override
+ public WorkspaceType getDefaultWorkspaceType() {
+ return WorkspaceType.GO;
+ }
+
+ @Nullable
+ @Override
+ public SourceFolderProvider getSourceFolderProvider(BlazeProjectData projectData) {
+ if (!projectData.workspaceLanguageSettings.isWorkspaceType(WorkspaceType.GO)) {
+ return null;
+ }
+ return GenericSourceFolderProvider.INSTANCE;
+ }
+
+ @Override
+ public void updateProjectStructure(
+ Project project,
+ BlazeContext context,
+ WorkspaceRoot workspaceRoot,
+ ProjectViewSet projectViewSet,
+ BlazeProjectData blazeProjectData,
+ @Nullable BlazeProjectData oldBlazeProjectData,
+ ModuleEditor moduleEditor,
+ Module workspaceModule,
+ ModifiableRootModel workspaceModifiableModel) {
+ if (!blazeProjectData.workspaceLanguageSettings.isLanguageActive(LanguageClass.GO)) {
+ return;
+ }
+ for (Library lib : getGoLibraries(project)) {
+ if (workspaceModifiableModel.findLibraryOrderEntry(lib) == null) {
+ workspaceModifiableModel.addLibraryEntry(lib);
+ }
+ }
+ }
+
+ private static List<Library> getGoLibraries(Project project) {
+ List<Library> libraries = Lists.newArrayList();
+ LibraryTablesRegistrar registrar = LibraryTablesRegistrar.getInstance();
+ for (Library lib : registrar.getLibraryTable().getLibraries()) {
+ if (BlazeGoLibrarySource.isGoLibrary(lib)) {
+ libraries.add(lib);
+ }
+ }
+
+ String moduleLibraryName =
+ String.format("%s <%s>", GO_LIBRARY_PREFIX, BlazeDataStorage.WORKSPACE_MODULE_NAME);
+ Library goModuleLibrary =
+ registrar.getLibraryTable(project).getLibraryByName(moduleLibraryName);
+ if (goModuleLibrary != null) {
+ libraries.add(goModuleLibrary);
+ }
+ return libraries;
+ }
+
+ /**
+ * By default the Go plugin will create duplicate copies of project libraries, one for each
+ * module. We only care about library associated with the workspace module.
+ */
+ static boolean isGoLibraryForModule(Library library, String moduleName) {
+ String name = library.getName();
+ return name != null && name.equals("GOPATH <" + moduleName + ">");
+ }
+
+ @Nullable
+ @Override
+ public LibrarySource getLibrarySource(BlazeProjectData blazeProjectData) {
+ if (!blazeProjectData.workspaceLanguageSettings.isLanguageActive(LanguageClass.GO)) {
+ return null;
+ }
+ return BlazeGoLibrarySource.INSTANCE;
+ }
+
+ @Override
+ public boolean validateProjectView(
+ BlazeContext context,
+ ProjectViewSet projectViewSet,
+ WorkspaceLanguageSettings workspaceLanguageSettings) {
+ if (!workspaceLanguageSettings.isLanguageActive(LanguageClass.GO)) {
+ return true;
+ }
+ if (!isPluginEnabled()) {
+ IssueOutput.error("Go plugin needed for Go language support.")
+ .navigatable(
+ new NavigatableAdapter() {
+ @Override
+ public void navigate(boolean requestFocus) {
+ if (isPluginInstalled()) {
+ PluginManager.enablePlugin(GO_PLUGIN_ID);
+ } else {
+ PluginsAdvertiser.installAndEnablePlugins(
+ ImmutableSet.of(GO_PLUGIN_ID), EmptyRunnable.INSTANCE);
+ }
+ }
+ })
+ .submit(context);
+ return false;
+ }
+ return true;
+ }
+
+ private static boolean isPluginInstalled() {
+ return PluginManager.isPluginInstalled(PluginId.getId(GO_PLUGIN_ID));
+ }
+
+ private static boolean isPluginEnabled() {
+ IdeaPluginDescriptor plugin = PluginManager.getPlugin(PluginId.getId(GO_PLUGIN_ID));
+ return plugin != null && plugin.isEnabled();
+ }
+
+ @Override
+ public void updateProjectSdk(
+ Project project,
+ BlazeContext context,
+ ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
+ BlazeProjectData blazeProjectData) {
+ if (!blazeProjectData.workspaceLanguageSettings.isWorkspaceType(WorkspaceType.GO)) {
+ return;
+ }
+ Sdk currentSdk = ProjectRootManager.getInstance(project).getProjectSdk();
+ if (currentSdk != null && currentSdk.getSdkType().getName().equals(GO_SDK_TYPE_ID)) {
+ return;
+ }
+ Sdk sdk = getOrCreateGoSdk();
+ if (sdk != null) {
+ setProjectSdk(project, sdk);
+ }
+ }
+
+ @Nullable
+ private static Sdk getOrCreateGoSdk() {
+ ProjectJdkTable sdkTable = ProjectJdkTable.getInstance();
+ SdkTypeId type = sdkTable.getSdkTypeByName(GO_SDK_TYPE_ID);
+ List<Sdk> sdk = sdkTable.getSdksOfType(type);
+ if (!sdk.isEmpty()) {
+ return sdk.get(0);
+ }
+ VirtualFile defaultSdk = GoSdkUtil.suggestSdkDirectory();
+ if (defaultSdk != null) {
+ return SdkConfigurationUtil.createAndAddSDK(defaultSdk.getPath(), (SdkType) type);
+ }
+ return null;
+ }
+
+ private static void setProjectSdk(Project project, Sdk sdk) {
+ Transactions.submitTransactionAndWait(
+ () ->
+ ApplicationManager.getApplication()
+ .runWriteAction(() -> ProjectRootManager.getInstance(project).setProjectSdk(sdk)));
+ }
+}
diff --git a/golang/tests/unittests/com/google/idea/blaze/golang/sync/BlazeGoSyncPluginTest.java b/golang/tests/unittests/com/google/idea/blaze/golang/sync/BlazeGoSyncPluginTest.java
new file mode 100644
index 0000000..e563a27
--- /dev/null
+++ b/golang/tests/unittests/com/google/idea/blaze/golang/sync/BlazeGoSyncPluginTest.java
@@ -0,0 +1,116 @@
+/*
+ * Copyright 2016 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.idea.blaze.golang.sync;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.ImmutableSet;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.base.model.primitives.LanguageClass;
+import com.google.idea.blaze.base.model.primitives.WorkspaceType;
+import com.google.idea.blaze.base.projectview.ProjectView;
+import com.google.idea.blaze.base.projectview.ProjectViewSet;
+import com.google.idea.blaze.base.projectview.section.ListSection;
+import com.google.idea.blaze.base.projectview.section.ScalarSection;
+import com.google.idea.blaze.base.projectview.section.sections.AdditionalLanguagesSection;
+import com.google.idea.blaze.base.projectview.section.sections.WorkspaceTypeSection;
+import com.google.idea.blaze.base.scope.BlazeContext;
+import com.google.idea.blaze.base.scope.ErrorCollector;
+import com.google.idea.blaze.base.scope.output.IssueOutput;
+import com.google.idea.blaze.base.sync.BlazeSyncPlugin;
+import com.google.idea.blaze.base.sync.projectview.LanguageSupport;
+import com.google.idea.blaze.base.sync.projectview.WorkspaceLanguageSettings;
+import com.intellij.openapi.extensions.impl.ExtensionPointImpl;
+import java.util.Set;
+import javax.annotation.Nullable;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link BlazeGoSyncPlugin} */
+@RunWith(JUnit4.class)
+public class BlazeGoSyncPluginTest extends BlazeTestCase {
+
+ private final ErrorCollector errorCollector = new ErrorCollector();
+ private BlazeContext context;
+ private ExtensionPointImpl<BlazeSyncPlugin> syncPluginEp;
+
+ @Override
+ protected void initTest(
+ @NotNull Container applicationServices, @NotNull Container projectServices) {
+ super.initTest(applicationServices, projectServices);
+
+ syncPluginEp = registerExtensionPoint(BlazeSyncPlugin.EP_NAME, BlazeSyncPlugin.class);
+ syncPluginEp.registerExtension(new BlazeGoSyncPlugin());
+ context = new BlazeContext();
+ context.addOutputSink(IssueOutput.class, errorCollector);
+ }
+
+ @Test
+ public void testGoWorkspaceTypeSupported() {
+ ProjectViewSet projectViewSet =
+ ProjectViewSet.builder()
+ .add(
+ ProjectView.builder()
+ .add(ScalarSection.builder(WorkspaceTypeSection.KEY).set(WorkspaceType.GO))
+ .build())
+ .build();
+ WorkspaceLanguageSettings workspaceLanguageSettings =
+ LanguageSupport.createWorkspaceLanguageSettings(context, projectViewSet);
+ errorCollector.assertNoIssues();
+ assertThat(workspaceLanguageSettings)
+ .isEqualTo(
+ new WorkspaceLanguageSettings(
+ WorkspaceType.GO, ImmutableSet.of(LanguageClass.GENERIC, LanguageClass.GO)));
+ }
+
+ @Test
+ public void testGoNotAValidAdditionalLanguage() {
+ // add a java sync plugin so we have another workspace type available
+ syncPluginEp.registerExtension(
+ new BlazeSyncPlugin.Adapter() {
+ @Override
+ public ImmutableList<WorkspaceType> getSupportedWorkspaceTypes() {
+ return ImmutableList.of(WorkspaceType.JAVA);
+ }
+
+ @Override
+ public Set<LanguageClass> getSupportedLanguagesInWorkspace(WorkspaceType workspaceType) {
+ return ImmutableSet.of(LanguageClass.JAVA);
+ }
+
+ @Nullable
+ @Override
+ public WorkspaceType getDefaultWorkspaceType() {
+ return WorkspaceType.JAVA;
+ }
+ });
+
+ ProjectViewSet projectViewSet =
+ ProjectViewSet.builder()
+ .add(
+ ProjectView.builder()
+ .add(ScalarSection.builder(WorkspaceTypeSection.KEY).set(WorkspaceType.JAVA))
+ .add(ListSection.builder(AdditionalLanguagesSection.KEY).add(LanguageClass.GO))
+ .build())
+ .build();
+ LanguageSupport.createWorkspaceLanguageSettings(context, projectViewSet);
+ errorCollector.assertIssueContaining(
+ "Language 'go' is not supported for this plugin with workspace type: 'java'");
+ }
+}
diff --git a/ijwb/BUILD b/ijwb/BUILD
index 0ec5aad..55b2b72 100644
--- a/ijwb/BUILD
+++ b/ijwb/BUILD
@@ -17,6 +17,7 @@
srcs = [
"src/META-INF/ijwb.xml",
"//base:plugin_xml",
+ "//golang:plugin_xml",
"//java:plugin_xml",
"//plugin_dev:plugin_xml",
],
@@ -50,6 +51,7 @@
],
deps = [
"//base",
+ "//golang",
"//intellij_platform_sdk:plugin_api",
"//java",
"@jsr305_annotations//jar",
diff --git a/ijwb/ijwb.bazelproject b/ijwb/ijwb.bazelproject
index e8fc755..6bf0977 100644
--- a/ijwb/ijwb.bazelproject
+++ b/ijwb/ijwb.bazelproject
@@ -11,6 +11,9 @@
workspace_type: intellij_plugin
+build_flags:
+ --define=ij_product=intellij-latest
+
test_sources:
*/tests/unittests*
*/tests/integrationtests*
diff --git a/intellij_platform_sdk/BUILD b/intellij_platform_sdk/BUILD
index 2f68436..9edcbbf 100644
--- a/intellij_platform_sdk/BUILD
+++ b/intellij_platform_sdk/BUILD
@@ -62,6 +62,14 @@
},
)
+# Android Studio 2.3.0.4
+config_setting(
+ name = "android-studio-2.3.0.4",
+ values = {
+ "define": "ij_product=android-studio-2.3.0.4",
+ },
+)
+
config_setting(
name = "clion-latest",
values = {
@@ -69,6 +77,14 @@
},
)
+# CLion 2016.3.2
+config_setting(
+ name = "clion-2016.3.2",
+ values = {
+ "define": "ij_product=clion-2016.3.2",
+ },
+)
+
# CLion 2016.2.2
config_setting(
name = "clion-162.1967.7",
@@ -77,16 +93,13 @@
},
)
-# CLion 16 (2016.2.1)
-config_setting(
- name = "clion-162.1628.20",
- values = {
- "define": "ij_product=clion-162.1628.20",
- },
+load(
+ ":build_defs.bzl",
+ "select_for_ide",
+ "select_for_plugin_api",
+ "select_from_plugin_api_directory",
)
-load(":build_defs.bzl", "select_from_plugin_api_directory", "select_for_ide")
-
# The purpose of this rule is to hide the versioning
# complexity from users of this api.
# There will be additional versions added in the future
@@ -96,6 +109,7 @@
android_studio = [
":sdk",
":android_plugin",
+ ":test_recorder",
],
clion = [":sdk"],
intellij = [":sdk"],
@@ -128,7 +142,7 @@
java_library(
name = "plugin_api_for_grammar_kit",
visibility = ["//third_party/java/jetbrains/grammar_kit:__pkg__"],
- exports = ["//intellij_platform_sdk/IC_162_2032_8:sdk"],
+ exports = ["//intellij_platform_sdk/intellij_ce_2016_3_1:sdk"],
)
# Used to support IntelliJ plugin development in our plugin
@@ -172,7 +186,25 @@
android_studio = [":bundled_plugins"],
clion = [":bundled_plugins"],
intellij = [":bundled_plugins"],
- ),
+ ) + [":missing_test_classes"],
+)
+
+# Certain plugin API releases don't contain test classes, so any testServiceImplemention
+# in an upstream plugin will cause an error when the plugin is loaded for integration tests.
+# Here we have dummy versions of these missing classes.
+java_library(
+ name = "missing_test_classes",
+ srcs = select_for_plugin_api({
+ "android-studio-2.3.0.3": [
+ "missing/tests/com/jetbrains/cidr/modulemap/resolve/MockModuleMapManagerImpl.java",
+ ],
+ "android-studio-2.3.0.4": [
+ "missing/tests/com/jetbrains/cidr/modulemap/resolve/MockModuleMapManagerImpl.java",
+ ],
+ "default": [],
+ }) + ["missing/src/dummy/pkg/DummyClassToAvoidAnEmptyJavaLibrary.java"],
+ tags = ["intellij-missing-test-classes"],
+ deps = [":plugin_api"],
)
filegroup(
@@ -189,6 +221,7 @@
srcs = select_for_ide(
android_studio = ["android_studio_application_info_name.txt"],
clion = ["clion_application_info_name.txt"],
+ default = ["intellij_application_info_name.txt"],
intellij = ["intellij_application_info_name.txt"],
),
)
diff --git a/intellij_platform_sdk/BUILD.clion b/intellij_platform_sdk/BUILD.clion
index e395d09..c83e150 100644
--- a/intellij_platform_sdk/BUILD.clion
+++ b/intellij_platform_sdk/BUILD.clion
@@ -26,4 +26,4 @@
filegroup(
name = "application_info_jar",
srcs = glob(["clion-*/lib/clion.jar"]),
-)
+)
\ No newline at end of file
diff --git a/intellij_platform_sdk/build_defs.bzl b/intellij_platform_sdk/build_defs.bzl
index 57dbe76..e7c5c2d 100644
--- a/intellij_platform_sdk/build_defs.bzl
+++ b/intellij_platform_sdk/build_defs.bzl
@@ -2,7 +2,7 @@
# The current indirect ij_product mapping (eg. "intellij-latest")
INDIRECT_IJ_PRODUCTS = {
- "intellij-latest": "intellij-162.2032.8",
+ "intellij-latest": "intellij-2016.3.1",
"android-studio-latest": "android-studio-145.1617.8",
"android-studio-beta": "android-studio-2.3.0.3",
"clion-latest": "clion-162.1967.7",
@@ -25,14 +25,18 @@
ide="android-studio",
directory="android_studio_2_3_0_3",
),
- "clion-162.1628.20": struct(
- ide="clion",
- directory="CL_162_1628_20",
+ "android-studio-2.3.0.4": struct(
+ ide="android-studio",
+ directory="android_studio_2_3_0_4",
),
"clion-162.1967.7": struct(
ide="clion",
directory="CL_162_1967_7",
),
+ "clion-2016.3.2": struct(
+ ide="clion",
+ directory="clion_2016_3_2",
+ ),
}
# BUILD_VARS for each IDE corresponding to indirect ij_products, eg. "intellij-latest"
@@ -50,11 +54,8 @@
You may only include direct ij_products here,
not indirects (eg. intellij-latest).
Returns:
- A select statement on all plugin_apis. Unless you include a "default"
- clause any other matched plugin_api will return "None".
-
- A build without an ij_product is considered equivalent to building with
- "intellij-latest".
+ A select statement on all plugin_apis. Unless you include a "default",
+ a non-matched plugin_api will result in an error.
Example:
java_library(
@@ -65,6 +66,9 @@
}),
)
"""
+ if not params:
+ fail("Empty select_for_plugin_api")
+
for indirect_ij_product in INDIRECT_IJ_PRODUCTS:
if indirect_ij_product in params:
error_message = "".join([
@@ -72,43 +76,27 @@
"Instead, select on an exact ij_product."])
fail(error_message)
- # To make the select work with "intellij-latest" and friends,
- # we find if the user is currently selecting on what intellij-latest
- # is resolving to, and copy that. Example:
+ expanded_params = dict(**params)
+
+ # Expand all indirect plugin_apis to point to their
+ # corresponding direct plugin_api.
#
- # {"intellij-2016.3.1": "stuff"} ->
- # {"intellij-2016.3.1": "stuff", "intellij-latest": "stuff"}
- params = dict(**params)
+ # {"intellij-2016.3.1": "foo"} ->
+ # {"intellij-2016.3.1": "foo", "intellij-latest": "foo"}
for indirect_ij_product, resolved_plugin_api in INDIRECT_IJ_PRODUCTS.items():
if resolved_plugin_api in params:
- params[indirect_ij_product] = params[resolved_plugin_api]
+ expanded_params[indirect_ij_product] = params[resolved_plugin_api]
- if "default" not in params:
- # If "intellij-latest" is supported, we set "default" to that
- # This supports building with an empty command line. Example:
- #
- # {"intellij-2016.3.1": "stuff", "intellij-latest": "stuff"} ->
- # {"intellij-2016.3.1": "stuff", "intellij-latest": "stuff", "default": "stuff"}
- if "intellij-latest" in params:
- params["default"] = params["intellij-latest"]
-
- # Add the other indirect ij_products returning None rather than default
- for ij_product in INDIRECT_IJ_PRODUCTS:
- if ij_product not in params:
- params[ij_product] = None
- for ij_product in DIRECT_IJ_PRODUCTS:
- if ij_product not in params:
- params[ij_product] = None
-
- # Map to the actual targets
+ # Map the shorthand ij_products to full config_setting targets.
# This makes it more convenient so the user doesn't have to
# fully specify the path to the plugin_apis
select_params = dict()
- for ij_product, value in params.items():
+ for ij_product, value in expanded_params.items():
if ij_product == "default":
select_params["//conditions:default"] = value
else:
select_params["//intellij_platform_sdk:" + ij_product] = value
+
return select(select_params)
def select_for_ide(intellij=None, android_studio=None, clion=None, default=None):
@@ -134,7 +122,6 @@
intellij = intellij or default
android_studio = android_studio or default
clion = clion or default
- default = default or intellij
ide_to_value = {
"intellij" : intellij,
@@ -166,4 +153,8 @@
params = dict()
for ij_product, value in DIRECT_IJ_PRODUCTS.items():
params[ij_product] = [_plugin_api_directory(value) + item for item in ide_to_value[value.ide]]
+
+ # No ij_product == intellij-latest
+ params["default"] = params[INDIRECT_IJ_PRODUCTS["intellij-latest"]]
+
return select_for_plugin_api(params)
diff --git a/java/BUILD b/java/BUILD
index 80799c3..ac9f772 100644
--- a/java/BUILD
+++ b/java/BUILD
@@ -6,10 +6,12 @@
visibility = ["//visibility:public"],
deps = [
"//base",
+ "//common/actionhelper",
"//common/experiments",
"//intellij_platform_sdk:junit",
"//intellij_platform_sdk:plugin_api",
"//proto_deps",
+ "//sdkcompat",
"@jsr305_annotations//jar",
],
)
diff --git a/java/src/META-INF/blaze-java.xml b/java/src/META-INF/blaze-java.xml
index ae7ca4d..5466c27 100644
--- a/java/src/META-INF/blaze-java.xml
+++ b/java/src/META-INF/blaze-java.xml
@@ -19,31 +19,34 @@
<actions>
<action class="com.google.idea.blaze.java.libraries.ExcludeLibraryAction"
- id="Blaze.ExcludeLibraryAction"
- icon="BlazeIcons.Blaze"
- text="Exclude Library and Resync">
- <add-to-group group-id="Blaze.ProjectViewPopupMenu"/>
+ id="Blaze.ExcludeLibraryAction"
+ text="Exclude Library and Resync">
</action>
<action class="com.google.idea.blaze.java.libraries.AttachSourceJarAction"
- id="Blaze.AttachSourceJarAction"
- icon="BlazeIcons.Blaze"
- text="Attach Source Jar">
- <add-to-group group-id="Blaze.ProjectViewPopupMenu"/>
+ id="Blaze.AttachSourceJarAction"
+ text="Attach Source Jar">
</action>
<action class="com.google.idea.blaze.java.libraries.AddLibraryTargetDirectoryToProjectViewAction"
- id="Blaze.AddLibraryTargetDirectoryToProjectView"
- icon="BlazeIcons.Blaze"
- text="Add Library Target Directory To Project View">
- <add-to-group group-id="Blaze.ProjectViewPopupMenu"/>
+ id="Blaze.AddLibraryTargetDirectoryToProjectView"
+ text="Add Library Target Directory to Project View">
+ </action>
+ <action class="com.google.idea.blaze.java.libraries.DetachAllSourceJarsAction"
+ id="Blaze.DetachAllSourceJars"
+ text="Detach All Blaze Source Jars">
</action>
- <group>
- <action class="com.google.idea.blaze.java.libraries.DetachAllSourceJarsAction"
- id="Blaze.DetachAllSourceJars"
- text="Detach All Blaze Source Jars">
- </action>
- <separator/>
- <add-to-group group-id="Blaze.MainMenuActionGroup" relative-to-action="Blaze.EditProjectView" anchor="before"/>
+ <group id="Blaze.Java.ProjectViewPopupMenu">
+ <add-to-group group-id="Blaze.ProjectViewPopupMenu"/>
+ <reference id="Blaze.ExcludeLibraryAction"/>
+ <reference id="Blaze.AttachSourceJarAction"/>
+ <reference id="Blaze.AddLibraryTargetDirectoryToProjectView"/>
+ </group>
+
+ <group id="Blaze.JavaMenuGroup.Outer">
+ <add-to-group group-id="Blaze.MainMenuActionGroup" relative-to-action="Blaze.MenuFooter" anchor="after"/>
+ <group id="Blaze.JavaMenuGroup" text="Java">
+ <reference id="Blaze.DetachAllSourceJars"/>
+ </group>
</group>
<!-- IntelliJ specific actions -->
@@ -92,6 +95,9 @@
<projectService serviceImplementation="com.google.idea.blaze.java.libraries.SourceJarManager"/>
<refactoring.safeDeleteProcessor id="build_file_safe_delete" order="before javaProcessor"
implementation="com.google.idea.blaze.java.lang.build.BuildFileSafeDeleteProcessor"/>
+ <!--duplicated here in case the Kotlin plugin is present, as it also tries to replace javaProcessor-->
+ <refactoring.safeDeleteProcessor id="build_file_safe_delete_copy" order="before kotlinProcessor"
+ implementation="com.google.idea.blaze.java.lang.build.BuildFileSafeDeleteProcessor"/>
<projectService serviceImplementation="com.google.idea.blaze.java.libraries.JarCache"/>
<attachSourcesProvider implementation="com.google.idea.blaze.java.libraries.AddLibraryTargetDirectoryToProjectViewAttachSourcesProvider"/>
diff --git a/java/src/com/google/idea/blaze/java/libraries/AddLibraryTargetDirectoryToProjectViewAction.java b/java/src/com/google/idea/blaze/java/libraries/AddLibraryTargetDirectoryToProjectViewAction.java
index 935fded..a954942 100644
--- a/java/src/com/google/idea/blaze/java/libraries/AddLibraryTargetDirectoryToProjectViewAction.java
+++ b/java/src/com/google/idea/blaze/java/libraries/AddLibraryTargetDirectoryToProjectViewAction.java
@@ -18,7 +18,7 @@
import com.google.common.base.Strings;
import com.google.common.collect.ImmutableList;
import com.google.common.collect.Sets;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.ideinfo.TargetIdeInfo;
import com.google.idea.blaze.base.ideinfo.TargetKey;
import com.google.idea.blaze.base.model.BlazeProjectData;
@@ -44,14 +44,12 @@
import java.io.File;
import java.util.List;
import java.util.Set;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import javax.annotation.Nullable;
-class AddLibraryTargetDirectoryToProjectViewAction extends BlazeAction {
+class AddLibraryTargetDirectoryToProjectViewAction extends BlazeProjectAction {
+
@Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- assert project != null;
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
Library library = LibraryActionHelper.findLibraryForAction(e);
if (library != null) {
addDirectoriesToProjectView(project, ImmutableList.of(library));
@@ -59,18 +57,15 @@
}
@Override
- protected void doUpdate(@NotNull AnActionEvent e) {
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
Presentation presentation = e.getPresentation();
boolean visible = false;
boolean enabled = false;
- Project project = e.getProject();
- if (project != null) {
- Library library = LibraryActionHelper.findLibraryForAction(e);
- if (library != null) {
- visible = true;
- if (getDirectoryToAddForLibrary(project, library) != null) {
- enabled = true;
- }
+ Library library = LibraryActionHelper.findLibraryForAction(e);
+ if (library != null) {
+ visible = true;
+ if (getDirectoryToAddForLibrary(project, library) != null) {
+ enabled = true;
}
}
presentation.setVisible(visible);
diff --git a/java/src/com/google/idea/blaze/java/libraries/AttachSourceJarAction.java b/java/src/com/google/idea/blaze/java/libraries/AttachSourceJarAction.java
index 7e18d28..9961f6f 100644
--- a/java/src/com/google/idea/blaze/java/libraries/AttachSourceJarAction.java
+++ b/java/src/com/google/idea/blaze/java/libraries/AttachSourceJarAction.java
@@ -15,7 +15,7 @@
*/
package com.google.idea.blaze.java.libraries;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.ideinfo.LibraryArtifact;
import com.google.idea.blaze.base.model.BlazeProjectData;
import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
@@ -30,13 +30,11 @@
import com.intellij.openapi.roots.libraries.Library;
import com.intellij.openapi.roots.libraries.LibraryTable;
import com.intellij.openapi.ui.Messages;
-import org.jetbrains.annotations.NotNull;
-class AttachSourceJarAction extends BlazeAction {
+class AttachSourceJarAction extends BlazeProjectAction {
+
@Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- assert project != null;
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
BlazeProjectData blazeProjectData =
BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
if (blazeProjectData == null) {
@@ -77,28 +75,25 @@
}
@Override
- protected void doUpdate(@NotNull AnActionEvent e) {
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
Presentation presentation = e.getPresentation();
String text = "Attach Source Jar";
boolean visible = false;
boolean enabled = false;
- Project project = e.getProject();
- if (project != null) {
- BlazeProjectData blazeProjectData =
- BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
- if (blazeProjectData != null) {
- Library library = LibraryActionHelper.findLibraryForAction(e);
- if (library != null) {
- visible = true;
+ BlazeProjectData blazeProjectData =
+ BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
+ if (blazeProjectData != null) {
+ Library library = LibraryActionHelper.findLibraryForAction(e);
+ if (library != null) {
+ visible = true;
- BlazeJarLibrary blazeLibrary =
- LibraryActionHelper.findLibraryFromIntellijLibrary(
- e.getProject(), blazeProjectData, library);
- if (blazeLibrary != null && blazeLibrary.libraryArtifact.sourceJar != null) {
- enabled = true;
- if (SourceJarManager.getInstance(project).hasSourceJarAttached(blazeLibrary.key)) {
- text = "Detach Source Jar";
- }
+ BlazeJarLibrary blazeLibrary =
+ LibraryActionHelper.findLibraryFromIntellijLibrary(
+ e.getProject(), blazeProjectData, library);
+ if (blazeLibrary != null && blazeLibrary.libraryArtifact.sourceJar != null) {
+ enabled = true;
+ if (SourceJarManager.getInstance(project).hasSourceJarAttached(blazeLibrary.key)) {
+ text = "Detach Source Jar";
}
}
}
diff --git a/java/src/com/google/idea/blaze/java/libraries/BlazeAttachSourceProvider.java b/java/src/com/google/idea/blaze/java/libraries/BlazeAttachSourceProvider.java
index 05759ba..b5305b3 100644
--- a/java/src/com/google/idea/blaze/java/libraries/BlazeAttachSourceProvider.java
+++ b/java/src/com/google/idea/blaze/java/libraries/BlazeAttachSourceProvider.java
@@ -26,6 +26,7 @@
import com.google.idea.blaze.base.sync.libraries.LibraryEditor;
import com.google.idea.blaze.java.settings.BlazeJavaUserSettings;
import com.google.idea.blaze.java.sync.model.BlazeJarLibrary;
+import com.google.idea.sdkcompat.transactions.Transactions;
import com.intellij.codeInsight.AttachSourcesProvider;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.project.Project;
@@ -35,7 +36,6 @@
import com.intellij.openapi.roots.libraries.LibraryTable;
import com.intellij.openapi.util.ActionCallback;
import com.intellij.psi.PsiFile;
-import com.intellij.util.ui.UIUtil;
import java.util.Collection;
import java.util.List;
import org.jetbrains.annotations.NotNull;
@@ -85,7 +85,8 @@
* corresponding user setting is active.
*/
if (BlazeJavaUserSettings.getInstance().getAttachSourcesOnDemand()) {
- UIUtil.invokeLaterIfNeeded(
+ Transactions.submitTransaction(
+ project,
() -> {
attachSources(project, blazeProjectData, librariesToAttachSourceTo);
});
diff --git a/java/src/com/google/idea/blaze/java/libraries/DetachAllSourceJarsAction.java b/java/src/com/google/idea/blaze/java/libraries/DetachAllSourceJarsAction.java
index 10f70a3..37188f6 100644
--- a/java/src/com/google/idea/blaze/java/libraries/DetachAllSourceJarsAction.java
+++ b/java/src/com/google/idea/blaze/java/libraries/DetachAllSourceJarsAction.java
@@ -16,7 +16,7 @@
package com.google.idea.blaze.java.libraries;
import com.google.common.collect.Lists;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.model.BlazeProjectData;
import com.google.idea.blaze.base.model.LibraryKey;
import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
@@ -30,12 +30,10 @@
import com.intellij.openapi.roots.libraries.LibraryTable;
import java.util.List;
-class DetachAllSourceJarsAction extends BlazeAction {
- @Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- assert project != null;
+class DetachAllSourceJarsAction extends BlazeProjectAction {
+ @Override
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
BlazeProjectData blazeProjectData =
BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
if (blazeProjectData == null) {
diff --git a/java/src/com/google/idea/blaze/java/libraries/ExcludeLibraryAction.java b/java/src/com/google/idea/blaze/java/libraries/ExcludeLibraryAction.java
index 53d4ae8..48ab1d2 100644
--- a/java/src/com/google/idea/blaze/java/libraries/ExcludeLibraryAction.java
+++ b/java/src/com/google/idea/blaze/java/libraries/ExcludeLibraryAction.java
@@ -15,7 +15,7 @@
*/
package com.google.idea.blaze.java.libraries;
-import com.google.idea.blaze.base.actions.BlazeAction;
+import com.google.idea.blaze.base.actions.BlazeProjectAction;
import com.google.idea.blaze.base.ideinfo.LibraryArtifact;
import com.google.idea.blaze.base.model.BlazeProjectData;
import com.google.idea.blaze.base.projectview.ProjectViewEdit;
@@ -33,13 +33,11 @@
import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.libraries.Library;
import com.intellij.openapi.ui.Messages;
-import org.jetbrains.annotations.NotNull;
-class ExcludeLibraryAction extends BlazeAction {
+class ExcludeLibraryAction extends BlazeProjectAction {
+
@Override
- public void actionPerformed(AnActionEvent e) {
- Project project = e.getProject();
- assert project != null;
+ protected void actionPerformedInBlazeProject(Project project, AnActionEvent e) {
BlazeProjectData blazeProjectData =
BlazeProjectDataManager.getInstance(project).getBlazeProjectData();
if (blazeProjectData == null) {
@@ -88,7 +86,7 @@
}
@Override
- protected void doUpdate(@NotNull AnActionEvent e) {
+ protected void updateForBlazeProject(Project project, AnActionEvent e) {
Presentation presentation = e.getPresentation();
boolean enabled = LibraryActionHelper.findLibraryForAction(e) != null;
presentation.setVisible(enabled);
diff --git a/java/src/com/google/idea/blaze/java/run/BlazeJavaDebuggerRunner.java b/java/src/com/google/idea/blaze/java/run/BlazeJavaDebuggerRunner.java
index 001f26e..33a6540 100644
--- a/java/src/com/google/idea/blaze/java/run/BlazeJavaDebuggerRunner.java
+++ b/java/src/com/google/idea/blaze/java/run/BlazeJavaDebuggerRunner.java
@@ -17,7 +17,7 @@
import com.google.idea.blaze.base.model.primitives.Kind;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
-import com.intellij.debugger.impl.GenericDebuggerRunner;
+import com.google.idea.sdkcompat.debugger.GenericDebuggerRunnerSdkCompatAdapter;
import com.intellij.execution.ExecutionException;
import com.intellij.execution.configurations.JavaParameters;
import com.intellij.execution.configurations.RemoteConnection;
@@ -27,19 +27,21 @@
import com.intellij.execution.executors.DefaultDebugExecutor;
import com.intellij.execution.runners.ExecutionEnvironment;
import com.intellij.execution.ui.RunContentDescriptor;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
+import javax.annotation.Nullable;
/** A runner that adapts the GenericDebuggerRunner to work with Blaze run configurations. */
-public class BlazeJavaDebuggerRunner extends GenericDebuggerRunner {
+public class BlazeJavaDebuggerRunner extends GenericDebuggerRunnerSdkCompatAdapter {
+
+ // wait 10 minutes for the blaze build to complete before connecting
+ private static final long POLL_TIMEOUT_MILLIS = 10 * 60 * 1000;
+
@Override
- @NotNull
public String getRunnerId() {
return "Blaze-Debug";
}
@Override
- public boolean canRun(@NotNull final String executorId, @NotNull final RunProfile profile) {
+ public boolean canRun(final String executorId, final RunProfile profile) {
if (executorId.equals(DefaultDebugExecutor.EXECUTOR_ID)
&& profile instanceof BlazeCommandRunConfiguration) {
BlazeCommandRunConfiguration configuration = (BlazeCommandRunConfiguration) profile;
@@ -61,13 +63,12 @@
@Override
@Nullable
public RunContentDescriptor createContentDescriptor(
- @NotNull RunProfileState state, @NotNull ExecutionEnvironment environment)
- throws ExecutionException {
+ RunProfileState state, ExecutionEnvironment environment) throws ExecutionException {
if (!(state instanceof BlazeJavaRunProfileState)) {
return null;
}
BlazeJavaRunProfileState blazeState = (BlazeJavaRunProfileState) state;
RemoteConnection connection = blazeState.getRemoteConnection();
- return attachVirtualMachine(state, environment, connection, true /* pollConnection */);
+ return attachVirtualMachine(state, environment, connection, POLL_TIMEOUT_MILLIS);
}
}
diff --git a/java/src/com/google/idea/blaze/java/run/BlazeJavaRunConfigurationHandler.java b/java/src/com/google/idea/blaze/java/run/BlazeJavaRunConfigurationHandler.java
index fd26ffd..479b964 100644
--- a/java/src/com/google/idea/blaze/java/run/BlazeJavaRunConfigurationHandler.java
+++ b/java/src/com/google/idea/blaze/java/run/BlazeJavaRunConfigurationHandler.java
@@ -22,6 +22,7 @@
import com.google.idea.blaze.base.run.confighandler.BlazeCommandRunConfigurationRunner;
import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
import com.google.idea.blaze.base.settings.Blaze;
+import com.google.idea.blaze.base.settings.Blaze.BuildSystem;
import com.intellij.execution.Executor;
import com.intellij.execution.configurations.RunConfiguration;
import com.intellij.execution.configurations.RunProfileState;
@@ -38,8 +39,9 @@
private final BlazeCommandRunConfigurationCommonState state;
public BlazeJavaRunConfigurationHandler(BlazeCommandRunConfiguration configuration) {
- this.buildSystemName = Blaze.buildSystemName(configuration.getProject());
- this.state = new BlazeCommandRunConfigurationCommonState(buildSystemName);
+ BuildSystem buildSystem = Blaze.getBuildSystem(configuration.getProject());
+ this.buildSystemName = buildSystem.getName();
+ this.state = new BlazeCommandRunConfigurationCommonState(buildSystem);
}
@Override
diff --git a/java/src/com/google/idea/blaze/java/run/BlazeJavaRunProfileState.java b/java/src/com/google/idea/blaze/java/run/BlazeJavaRunProfileState.java
index a712e65..47b971b 100644
--- a/java/src/com/google/idea/blaze/java/run/BlazeJavaRunProfileState.java
+++ b/java/src/com/google/idea/blaze/java/run/BlazeJavaRunProfileState.java
@@ -28,8 +28,10 @@
import com.google.idea.blaze.base.projectview.ProjectViewManager;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
+import com.google.idea.blaze.base.run.DistributedExecutorSupport;
import com.google.idea.blaze.base.run.processhandler.LineProcessingProcessAdapter;
import com.google.idea.blaze.base.run.processhandler.ScopedBlazeProcessHandler;
+import com.google.idea.blaze.base.run.smrunner.SmRunnerUtils;
import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
import com.google.idea.blaze.base.scope.BlazeContext;
import com.google.idea.blaze.base.scope.scopes.IdeaLogScope;
@@ -38,14 +40,22 @@
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.settings.BlazeImportSettings;
import com.google.idea.blaze.base.settings.BlazeImportSettingsManager;
+import com.google.idea.common.experiments.BoolExperiment;
+import com.intellij.execution.DefaultExecutionResult;
import com.intellij.execution.ExecutionException;
+import com.intellij.execution.ExecutionResult;
+import com.intellij.execution.Executor;
import com.intellij.execution.configurations.CommandLineState;
import com.intellij.execution.configurations.RemoteConnection;
import com.intellij.execution.configurations.RemoteState;
import com.intellij.execution.configurations.RunProfile;
+import com.intellij.execution.configurations.WrappingRunConfiguration;
+import com.intellij.execution.filters.TextConsoleBuilderImpl;
import com.intellij.execution.process.ProcessHandler;
import com.intellij.execution.process.ProcessListener;
import com.intellij.execution.runners.ExecutionEnvironment;
+import com.intellij.execution.runners.ProgramRunner;
+import com.intellij.execution.ui.ConsoleView;
import com.intellij.openapi.project.Project;
/**
@@ -54,6 +64,10 @@
* when using a debug executor.
*/
final class BlazeJavaRunProfileState extends CommandLineState implements RemoteState {
+
+ private static final BoolExperiment smRunnerUiEnabled =
+ new BoolExperiment("use.smrunner.ui.java", true);
+
// Blaze seems to always use this port for --java_debug.
// TODO(joshgiles): Look at manually identifying and setting port.
private static final int DEBUG_PORT = 5005;
@@ -64,12 +78,18 @@
public BlazeJavaRunProfileState(ExecutionEnvironment environment, boolean debug) {
super(environment);
- RunProfile runProfile = environment.getRunProfile();
- assert runProfile instanceof BlazeCommandRunConfiguration;
- configuration = (BlazeCommandRunConfiguration) runProfile;
+ this.configuration = getConfiguration(environment);
this.debug = debug;
}
+ private static BlazeCommandRunConfiguration getConfiguration(ExecutionEnvironment environment) {
+ RunProfile runProfile = environment.getRunProfile();
+ if (runProfile instanceof WrappingRunConfiguration) {
+ runProfile = ((WrappingRunConfiguration) runProfile).getPeer();
+ }
+ return (BlazeCommandRunConfiguration) runProfile;
+ }
+
@Override
protected ProcessHandler startProcess() throws ExecutionException {
Project project = configuration.getProject();
@@ -80,7 +100,25 @@
ProjectViewSet projectViewSet = ProjectViewManager.getInstance(project).getProjectViewSet();
assert projectViewSet != null;
- BlazeCommand blazeCommand = getBlazeCommand(project, configuration, projectViewSet, debug);
+ BlazeCommand blazeCommand;
+ if (useTestUi()) {
+ BlazeJavaTestEventsHandler eventsHandler = new BlazeJavaTestEventsHandler();
+ blazeCommand =
+ getBlazeCommand(
+ project, configuration, projectViewSet, eventsHandler.getBlazeFlags(), debug);
+ setConsoleBuilder(
+ new TextConsoleBuilderImpl(project) {
+ @Override
+ protected ConsoleView createConsole() {
+ return SmRunnerUtils.getConsoleView(
+ project, configuration, getEnvironment().getExecutor(), eventsHandler);
+ }
+ });
+ } else {
+ blazeCommand =
+ getBlazeCommand(project, configuration, projectViewSet, ImmutableList.of(), debug);
+ }
+
WorkspaceRoot workspaceRoot = WorkspaceRoot.fromImportSettings(importSettings);
return new ScopedBlazeProcessHandler(
project,
@@ -106,6 +144,24 @@
}
@Override
+ public ExecutionResult execute(Executor executor, ProgramRunner runner)
+ throws ExecutionException {
+ DefaultExecutionResult result = (DefaultExecutionResult) super.execute(executor, runner);
+ return SmRunnerUtils.attachRerunFailedTestsAction(result);
+ }
+
+ private boolean useTestUi() {
+ if (!smRunnerUiEnabled.getValue()) {
+ return false;
+ }
+ BlazeCommandRunConfigurationCommonState state =
+ configuration.getHandlerStateIfType(BlazeCommandRunConfigurationCommonState.class);
+ return state != null
+ && BlazeCommandName.TEST.equals(state.getCommand())
+ && !Boolean.TRUE.equals(state.getRunOnDistributedExecutor());
+ }
+
+ @Override
public RemoteConnection getRemoteConnection() {
if (!debug) {
return null;
@@ -122,6 +178,7 @@
Project project,
BlazeCommandRunConfiguration configuration,
ProjectViewSet projectViewSet,
+ ImmutableList<String> extraBlazeFlags,
boolean debug) {
BlazeCommandRunConfigurationCommonState handlerState =
@@ -135,6 +192,7 @@
.setBlazeBinary(handlerState.getBlazeBinary())
.addTargets(configuration.getTarget())
.addBlazeFlags(BlazeFlags.buildFlags(project, projectViewSet))
+ .addBlazeFlags(extraBlazeFlags)
.addBlazeFlags(handlerState.getBlazeFlags());
if (debug) {
@@ -145,6 +203,10 @@
} else {
command.addBlazeFlags(BlazeFlags.JAVA_TEST_DEBUG);
}
+ } else {
+ command.addBlazeFlags(
+ DistributedExecutorSupport.getBlazeFlags(
+ project, handlerState.getRunOnDistributedExecutor()));
}
command.addExeFlags(handlerState.getExeFlags());
diff --git a/java/src/com/google/idea/blaze/java/run/BlazeJavaTestEventsHandler.java b/java/src/com/google/idea/blaze/java/run/BlazeJavaTestEventsHandler.java
new file mode 100644
index 0000000..9af9b64
--- /dev/null
+++ b/java/src/com/google/idea/blaze/java/run/BlazeJavaTestEventsHandler.java
@@ -0,0 +1,94 @@
+/*
+ * Copyright 2016 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.idea.blaze.java.run;
+
+import com.google.idea.blaze.base.command.BlazeFlags;
+import com.google.idea.blaze.base.run.smrunner.BlazeTestEventsHandler;
+import com.google.idea.blaze.java.run.producers.BlazeJUnitTestFilterFlags;
+import com.intellij.execution.Location;
+import com.intellij.execution.testframework.AbstractTestProxy;
+import com.intellij.execution.testframework.JavaTestLocator;
+import com.intellij.execution.testframework.sm.runner.SMTestLocator;
+import com.intellij.openapi.project.Project;
+import com.intellij.openapi.util.text.StringUtil;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiElement;
+import com.intellij.psi.PsiMethod;
+import com.intellij.psi.search.GlobalSearchScope;
+import com.intellij.util.containers.MultiMap;
+import com.intellij.util.io.URLUtil;
+import java.util.List;
+import javax.annotation.Nullable;
+
+/** Provides java-specific methods needed by the SM-runner test UI. */
+public class BlazeJavaTestEventsHandler extends BlazeTestEventsHandler {
+
+ public BlazeJavaTestEventsHandler() {
+ super("Blaze Java Test");
+ }
+
+ @Override
+ public SMTestLocator getTestLocator() {
+ return JavaTestLocator.INSTANCE;
+ }
+
+ @Override
+ public String suiteLocationUrl(String name) {
+ return JavaTestLocator.SUITE_PROTOCOL + URLUtil.SCHEME_SEPARATOR + name;
+ }
+
+ @Override
+ public String testLocationUrl(String name, @Nullable String classname) {
+ if (classname == null) {
+ return null;
+ }
+ return JavaTestLocator.TEST_PROTOCOL + URLUtil.SCHEME_SEPARATOR + classname + "." + name;
+ }
+
+ @Override
+ public String suiteDisplayName(String rawName) {
+ String name = StringUtil.trimEnd(rawName, '.');
+ int lastPointIx = name.lastIndexOf('.');
+ return lastPointIx != -1 ? name.substring(lastPointIx + 1, name.length()) : name;
+ }
+
+ @Nullable
+ @Override
+ public String getTestFilter(Project project, List<AbstractTestProxy> failedTests) {
+ GlobalSearchScope projectScope = GlobalSearchScope.allScope(project);
+ MultiMap<PsiClass, PsiMethod> failedMethodsPerClass = new MultiMap<>();
+ for (AbstractTestProxy test : failedTests) {
+ appendTest(failedMethodsPerClass, test.getLocation(project, projectScope));
+ }
+ String filter = BlazeJUnitTestFilterFlags.testFilterForClassesAndMethods(failedMethodsPerClass);
+ return filter != null ? BlazeFlags.TEST_FILTER + "=" + filter : null;
+ }
+
+ private static void appendTest(
+ MultiMap<PsiClass, PsiMethod> testMap, @Nullable Location<?> testLocation) {
+ if (testLocation == null) {
+ return;
+ }
+ PsiElement method = testLocation.getPsiElement();
+ if (!(method instanceof PsiMethod)) {
+ return;
+ }
+ PsiClass psiClass = ((PsiMethod) method).getContainingClass();
+ if (psiClass != null) {
+ testMap.putValue(psiClass, (PsiMethod) method);
+ }
+ }
+}
diff --git a/java/src/com/google/idea/blaze/java/run/producers/BlazeJUnitTestFilterFlags.java b/java/src/com/google/idea/blaze/java/run/producers/BlazeJUnitTestFilterFlags.java
index 2c6a6aa..8f2290f 100644
--- a/java/src/com/google/idea/blaze/java/run/producers/BlazeJUnitTestFilterFlags.java
+++ b/java/src/com/google/idea/blaze/java/run/producers/BlazeJUnitTestFilterFlags.java
@@ -16,76 +16,147 @@
package com.google.idea.blaze.java.run.producers;
+import com.google.common.annotations.VisibleForTesting;
import com.google.common.base.Strings;
-import com.google.idea.blaze.base.command.BlazeFlags;
-import com.google.idea.common.experiments.BoolExperiment;
+import com.google.common.collect.ImmutableList;
+import com.intellij.execution.junit.JUnitUtil;
+import com.intellij.execution.junit2.PsiMemberParameterizedLocation;
+import com.intellij.psi.PsiClass;
+import com.intellij.psi.PsiMethod;
+import com.intellij.util.containers.MultiMap;
import java.util.Collection;
+import java.util.List;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
import javax.annotation.Nullable;
/** Utilities for building test filter flags for JUnit tests. */
public final class BlazeJUnitTestFilterFlags {
- private static final BoolExperiment enableParameterizedSupport =
- new BoolExperiment("enable.parameterized.test.support", true);
-
/** A version of JUnit to generate test filter flags for. */
public enum JUnitVersion {
JUNIT_3,
JUNIT_4
}
- public static String testFilterFlagForClass(String className, JUnitVersion jUnitVersion) {
- return testFilterFlagForClassAndMethod(
- className, null, jUnitVersion, /* parameterized doesn't matter for a class */ false);
+ /**
+ * Builds the JUnit test filter corresponding to the given class.<br>
+ * Returns null if no class name can be found.
+ */
+ @Nullable
+ public static String testFilterForClass(PsiClass psiClass) {
+ return testFilterForClassAndMethods(psiClass, ImmutableList.of());
}
- public static String testFilterFlagForClassAndMethod(
+ /**
+ * Builds the JUnit test filter corresponding to the given class and methods.<br>
+ * Returns null if no class name can be found.
+ */
+ @Nullable
+ public static String testFilterForClassAndMethods(
+ PsiClass psiClass, Collection<PsiMethod> methods) {
+ JUnitVersion version =
+ JUnitUtil.isJUnit4TestClass(psiClass) ? JUnitVersion.JUNIT_4 : JUnitVersion.JUNIT_3;
+ return testFilterForClassAndMethods(psiClass, version, methods);
+ }
+
+ @Nullable
+ public static String testFilterForClassesAndMethods(
+ MultiMap<PsiClass, PsiMethod> methodsPerClass) {
+ // Note: this could be incorrect if there are no JUnit4 classes in this sample, but some in the
+ // java_test target they're run from.
+ JUnitVersion version =
+ hasJUnit4Test(methodsPerClass.keySet()) ? JUnitVersion.JUNIT_4 : JUnitVersion.JUNIT_3;
+ return testFilterForClassesAndMethods(methodsPerClass, version);
+ }
+
+ @Nullable
+ public static String testFilterForClassesAndMethods(
+ MultiMap<PsiClass, PsiMethod> methodsPerClass, JUnitVersion version) {
+ StringBuilder output = new StringBuilder();
+ for (Entry<PsiClass, Collection<PsiMethod>> entry : methodsPerClass.entrySet()) {
+ String filter = testFilterForClassAndMethods(entry.getKey(), version, entry.getValue());
+ if (filter != null) {
+ output.append(filter);
+ }
+ }
+ return Strings.emptyToNull(output.toString());
+ }
+
+ private static boolean hasJUnit4Test(Collection<PsiClass> classes) {
+ for (PsiClass psiClass : classes) {
+ if (JUnitUtil.isJUnit4TestClass(psiClass)) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+ /**
+ * Builds the JUnit test filter corresponding to the given class and methods.<br>
+ * Returns null if no class name can be found.
+ */
+ @Nullable
+ private static String testFilterForClassAndMethods(
+ PsiClass psiClass, JUnitVersion version, Collection<PsiMethod> methods) {
+ String className = psiClass.getQualifiedName();
+ if (className == null) {
+ return null;
+ }
+ // Sort so multiple configurations created with different selection orders are the same.
+ List<String> methodNames =
+ methods.stream().map(PsiMethod::getName).sorted().collect(Collectors.toList());
+ return testFilterForClassAndMethods(className, methodNames, version, isParameterized(psiClass));
+ }
+
+ private static boolean isParameterized(PsiClass testClass) {
+ return PsiMemberParameterizedLocation.getParameterizedLocation(testClass, null) != null;
+ }
+
+ /**
+ * Builds the blaze test_filter flag for JUnit tests. Excludes the "--test_filter" component of
+ * the flag, so that multiple test classes can be combined.
+ */
+ @VisibleForTesting
+ static String testFilterForClassAndMethods(
String className,
- @Nullable String methodName,
+ List<String> methodNames,
JUnitVersion jUnitVersion,
boolean parameterized) {
- StringBuilder output = new StringBuilder(BlazeFlags.TEST_FILTER);
- output.append('=');
- output.append(className);
-
- if (!Strings.isNullOrEmpty(methodName)) {
- output.append('#');
- output.append(methodName);
- // JUnit 4 test filters are regexes, and must be terminated to avoid matching
- // unintended classes/methods. JUnit 3 test filters do not need or support this syntax.
+ StringBuilder output = new StringBuilder(className);
+ String methodNamePattern = concatenateMethodNames(methodNames, jUnitVersion);
+ if (Strings.isNullOrEmpty(methodNamePattern)) {
if (jUnitVersion == JUnitVersion.JUNIT_4) {
- // parameterized tests include their parameters between brackets after the method name
- if (parameterized && enableParameterizedSupport.getValue()) {
- output.append("(\\[.+\\])?");
- }
- output.append("$");
+ output.append('#');
}
- } else if (jUnitVersion == JUnitVersion.JUNIT_4) {
- output.append('#');
+ return output.toString();
}
-
+ output.append('#').append(methodNamePattern);
+ // JUnit 4 test filters are regexes, and must be terminated to avoid matching
+ // unintended classes/methods. JUnit 3 test filters do not need or support this syntax.
+ if (jUnitVersion == JUnitVersion.JUNIT_3) {
+ return output.toString();
+ }
+ // parameterized tests include their parameters between brackets after the method name
+ if (parameterized) {
+ output.append("(\\[.+\\])?");
+ }
+ output.append('$');
return output.toString();
}
- public static String testFilterFlagForClassAndMethods(
- String className,
- Collection<String> methodNames,
- JUnitVersion jUnitVersion,
- boolean parameterized) {
- if (methodNames.size() == 0) {
- return testFilterFlagForClass(className, jUnitVersion);
- } else if (methodNames.size() == 1) {
- return testFilterFlagForClassAndMethod(
- className, methodNames.iterator().next(), jUnitVersion, parameterized);
+ @Nullable
+ private static String concatenateMethodNames(
+ List<String> methodNames, JUnitVersion jUnitVersion) {
+ if (methodNames.isEmpty()) {
+ return null;
}
- String methodNamePattern;
- if (jUnitVersion == JUnitVersion.JUNIT_4) {
- methodNamePattern = String.format("(%s)", String.join("|", methodNames));
- } else {
- methodNamePattern = String.join(",", methodNames);
+ if (methodNames.size() == 1) {
+ return methodNames.get(0);
}
- return testFilterFlagForClassAndMethod(
- className, methodNamePattern, jUnitVersion, parameterized);
+ return jUnitVersion == JUnitVersion.JUNIT_4
+ ? String.format("(%s)", String.join("|", methodNames))
+ : String.join(",", methodNames);
}
private BlazeJUnitTestFilterFlags() {}
diff --git a/java/src/com/google/idea/blaze/java/run/producers/BlazeJavaTestClassConfigurationProducer.java b/java/src/com/google/idea/blaze/java/run/producers/BlazeJavaTestClassConfigurationProducer.java
index 3eb8ab3..95bc4ee 100644
--- a/java/src/com/google/idea/blaze/java/run/producers/BlazeJavaTestClassConfigurationProducer.java
+++ b/java/src/com/google/idea/blaze/java/run/producers/BlazeJavaTestClassConfigurationProducer.java
@@ -26,7 +26,6 @@
import com.google.idea.blaze.base.run.producers.BlazeRunConfigurationProducer;
import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
import com.google.idea.blaze.java.run.RunUtil;
-import com.google.idea.blaze.java.run.producers.BlazeJUnitTestFilterFlags.JUnitVersion;
import com.intellij.execution.JavaExecutionUtil;
import com.intellij.execution.Location;
import com.intellij.execution.actions.ConfigurationContext;
@@ -36,7 +35,6 @@
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiMethod;
import com.intellij.psi.PsiModifier;
-import java.util.List;
import java.util.Objects;
import org.jetbrains.annotations.NotNull;
@@ -90,13 +88,10 @@
ImmutableList.Builder<String> flags = ImmutableList.builder();
- final String qualifiedName = testClass.getQualifiedName();
- if (qualifiedName != null) {
- final JUnitVersion jUnitVersion =
- JUnitUtil.isJUnit4TestClass(testClass) ? JUnitVersion.JUNIT_4 : JUnitVersion.JUNIT_3;
- flags.add(BlazeJUnitTestFilterFlags.testFilterFlagForClass(qualifiedName, jUnitVersion));
+ String testFilter = BlazeJUnitTestFilterFlags.testFilterForClass(testClass);
+ if (testFilter != null) {
+ flags.add(BlazeFlags.TEST_FILTER + "=" + testFilter);
}
-
flags.add(BlazeFlags.TEST_OUTPUT_STREAMED);
flags.addAll(handlerState.getBlazeFlags());
@@ -147,12 +142,7 @@
if (!Objects.equals(handlerState.getCommand(), BlazeCommandName.TEST)) {
return false;
}
- List<String> flags = handlerState.getBlazeFlags();
-
- final JUnitVersion jUnitVersion =
- JUnitUtil.isJUnit4TestClass(testClass) ? JUnitVersion.JUNIT_4 : JUnitVersion.JUNIT_3;
- return flags.contains(
- BlazeJUnitTestFilterFlags.testFilterFlagForClass(
- testClass.getQualifiedName(), jUnitVersion));
+ String filter = BlazeJUnitTestFilterFlags.testFilterForClass(testClass);
+ return Objects.equals(filter, handlerState.getTestFilterFlag());
}
}
diff --git a/java/src/com/google/idea/blaze/java/run/producers/BlazeJavaTestMethodConfigurationProducer.java b/java/src/com/google/idea/blaze/java/run/producers/BlazeJavaTestMethodConfigurationProducer.java
index 2fc899f..1a7e149 100644
--- a/java/src/com/google/idea/blaze/java/run/producers/BlazeJavaTestMethodConfigurationProducer.java
+++ b/java/src/com/google/idea/blaze/java/run/producers/BlazeJavaTestMethodConfigurationProducer.java
@@ -26,18 +26,14 @@
import com.google.idea.blaze.base.run.producers.BlazeRunConfigurationProducer;
import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
import com.google.idea.blaze.java.run.RunUtil;
-import com.google.idea.blaze.java.run.producers.BlazeJUnitTestFilterFlags.JUnitVersion;
import com.intellij.execution.actions.ConfigurationContext;
-import com.intellij.execution.junit.JUnitUtil;
-import com.intellij.execution.junit2.PsiMemberParameterizedLocation;
import com.intellij.openapi.util.Ref;
import com.intellij.psi.PsiClass;
import com.intellij.psi.PsiElement;
import com.intellij.psi.PsiMethod;
-import java.util.ArrayList;
-import java.util.Collections;
import java.util.List;
import java.util.Objects;
+import java.util.stream.Collectors;
import org.jetbrains.annotations.NotNull;
/** Producer for run configurations related to Java test methods in Blaze. */
@@ -152,29 +148,15 @@
return null;
}
}
-
- final List<String> methodNames = new ArrayList<>();
- for (PsiMethod method : selectedMethods) {
- methodNames.add(method.getName());
- }
- // Sort so multiple configurations created with different selection orders are the same.
- Collections.sort(methodNames);
-
- final String qualifiedName = containingClass.getQualifiedName();
- if (qualifiedName == null) {
+ String testFilter =
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(containingClass, selectedMethods);
+ if (testFilter == null) {
return null;
}
- final JUnitVersion jUnitVersion =
- JUnitUtil.isJUnit4TestClass(containingClass) ? JUnitVersion.JUNIT_4 : JUnitVersion.JUNIT_3;
- boolean parameterized = isParameterized(containingClass);
- final String testFilterFlag =
- BlazeJUnitTestFilterFlags.testFilterFlagForClassAndMethods(
- qualifiedName, methodNames, jUnitVersion, parameterized);
-
+ // Sort so multiple configurations created with different selection orders are the same.
+ List<String> methodNames =
+ selectedMethods.stream().map(PsiMethod::getName).sorted().collect(Collectors.toList());
+ final String testFilterFlag = BlazeFlags.TEST_FILTER + "=" + testFilter;
return new SelectedMethodInfo(firstMethod, containingClass, methodNames, testFilterFlag);
}
-
- private static boolean isParameterized(PsiClass testClass) {
- return PsiMemberParameterizedLocation.getParameterizedLocation(testClass, null) != null;
- }
}
diff --git a/java/src/com/google/idea/blaze/java/sync/BlazeJavaSyncPlugin.java b/java/src/com/google/idea/blaze/java/sync/BlazeJavaSyncPlugin.java
index 65151a6..b971b94 100644
--- a/java/src/com/google/idea/blaze/java/sync/BlazeJavaSyncPlugin.java
+++ b/java/src/com/google/idea/blaze/java/sync/BlazeJavaSyncPlugin.java
@@ -22,6 +22,7 @@
import com.google.idea.blaze.base.ideinfo.TargetMap;
import com.google.idea.blaze.base.model.BlazeLibrary;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.SyncState;
import com.google.idea.blaze.base.model.primitives.LanguageClass;
import com.google.idea.blaze.base.model.primitives.WorkspaceRoot;
@@ -56,6 +57,7 @@
import com.google.idea.blaze.java.sync.projectstructure.JavaSourceFolderProvider;
import com.google.idea.blaze.java.sync.projectstructure.Jdks;
import com.google.idea.blaze.java.sync.workingset.JavaWorkingSet;
+import com.google.idea.sdkcompat.transactions.Transactions;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.module.ModuleType;
import com.intellij.openapi.module.StdModuleTypes;
@@ -64,7 +66,6 @@
import com.intellij.openapi.roots.LanguageLevelProjectExtension;
import com.intellij.openapi.roots.ex.ProjectRootManagerEx;
import com.intellij.pom.java.LanguageLevel;
-import com.intellij.util.ui.UIUtil;
import java.util.Collection;
import java.util.Set;
import javax.annotation.Nullable;
@@ -170,6 +171,7 @@
Project project,
BlazeContext context,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
BlazeProjectData blazeProjectData) {
if (!blazeProjectData.workspaceLanguageSettings.isWorkspaceType(WorkspaceType.JAVA)) {
return;
@@ -212,19 +214,18 @@
private static void setProjectSdkAndLanguageLevel(
final Project project, final Sdk sdk, final LanguageLevel javaLanguageLevel) {
- UIUtil.invokeAndWaitIfNeeded(
- (Runnable)
- () ->
- ApplicationManager.getApplication()
- .runWriteAction(
- () -> {
- ProjectRootManagerEx rootManager =
- ProjectRootManagerEx.getInstanceEx(project);
- rootManager.setProjectSdk(sdk);
- LanguageLevelProjectExtension ext =
- LanguageLevelProjectExtension.getInstance(project);
- ext.setLanguageLevel(javaLanguageLevel);
- }));
+ Transactions.submitTransactionAndWait(
+ () ->
+ ApplicationManager.getApplication()
+ .runWriteAction(
+ () -> {
+ ProjectRootManagerEx rootManager =
+ ProjectRootManagerEx.getInstanceEx(project);
+ rootManager.setProjectSdk(sdk);
+ LanguageLevelProjectExtension ext =
+ LanguageLevelProjectExtension.getInstance(project);
+ ext.setLanguageLevel(javaLanguageLevel);
+ }));
}
@Override
diff --git a/java/src/com/google/idea/blaze/java/sync/projectstructure/JavaSourceFolderProvider.java b/java/src/com/google/idea/blaze/java/sync/projectstructure/JavaSourceFolderProvider.java
index 5855655..abe5804 100644
--- a/java/src/com/google/idea/blaze/java/sync/projectstructure/JavaSourceFolderProvider.java
+++ b/java/src/com/google/idea/blaze/java/sync/projectstructure/JavaSourceFolderProvider.java
@@ -23,6 +23,7 @@
import com.google.idea.blaze.java.sync.model.BlazeJavaSyncData;
import com.google.idea.blaze.java.sync.model.BlazeSourceDirectory;
import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.diagnostic.Logger;
import com.intellij.openapi.roots.ContentEntry;
import com.intellij.openapi.roots.SourceFolder;
import com.intellij.openapi.util.io.FileUtil;
@@ -42,6 +43,7 @@
/** Edits source folders in IntelliJ content entries */
public class JavaSourceFolderProvider implements SourceFolderProvider {
+ private static final Logger logger = Logger.getInstance(JavaSourceFolderProvider.class);
private final ImmutableMap<File, BlazeContentEntry> blazeContentEntries;
@@ -106,6 +108,7 @@
private static String derivePackagePrefix(VirtualFile file, SourceFolder parentFolder) {
String parentPackagePrefix = parentFolder.getPackagePrefix();
+ logger.assertTrue(parentFolder.getFile() != null);
String relativePath = VfsUtilCore.getRelativePath(file, parentFolder.getFile(), '.');
if (Strings.isNullOrEmpty(relativePath)) {
return parentPackagePrefix;
diff --git a/java/tests/unittests/com/google/idea/blaze/java/run/BlazeJavaRunProfileStateTest.java b/java/tests/unittests/com/google/idea/blaze/java/run/BlazeJavaRunProfileStateTest.java
index 3f3aede..10e43eb 100644
--- a/java/tests/unittests/com/google/idea/blaze/java/run/BlazeJavaRunProfileStateTest.java
+++ b/java/tests/unittests/com/google/idea/blaze/java/run/BlazeJavaRunProfileStateTest.java
@@ -29,6 +29,7 @@
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.google.idea.blaze.base.run.BlazeCommandRunConfiguration;
import com.google.idea.blaze.base.run.BlazeCommandRunConfigurationType;
+import com.google.idea.blaze.base.run.DistributedExecutorSupport;
import com.google.idea.blaze.base.run.confighandler.BlazeCommandGenericRunConfigurationHandlerProvider;
import com.google.idea.blaze.base.run.confighandler.BlazeCommandRunConfigurationHandlerProvider;
import com.google.idea.blaze.base.run.state.BlazeCommandRunConfigurationCommonState;
@@ -68,6 +69,7 @@
applicationServices.register(TargetFinder.class, new MockTargetFinder());
applicationServices.register(BlazeUserSettings.class, new BlazeUserSettings());
registerExtensionPoint(BuildFlagsProvider.EP_NAME, BuildFlagsProvider.class);
+ registerExtensionPoint(DistributedExecutorSupport.EP_NAME, DistributedExecutorSupport.class);
ExtensionPointImpl<BlazeCommandRunConfigurationHandlerProvider> handlerProviderEp =
registerExtensionPoint(
BlazeCommandRunConfigurationHandlerProvider.EP_NAME,
@@ -87,7 +89,11 @@
handlerState.setBlazeFlags(ImmutableList.of("--flag1", "--flag2"));
assertThat(
BlazeJavaRunProfileState.getBlazeCommand(
- project, configuration, ProjectViewSet.builder().build(), false /* debug */)
+ project,
+ configuration,
+ ProjectViewSet.builder().build(),
+ ImmutableList.of(),
+ false /* debug */)
.toList())
.isEqualTo(
ImmutableList.of(
@@ -108,7 +114,11 @@
handlerState.setCommand(BlazeCommandName.fromString("command"));
assertThat(
BlazeJavaRunProfileState.getBlazeCommand(
- project, configuration, ProjectViewSet.builder().build(), true /* debug */)
+ project,
+ configuration,
+ ProjectViewSet.builder().build(),
+ ImmutableList.of(),
+ true /* debug */)
.toList())
.isEqualTo(
ImmutableList.of(
@@ -128,7 +138,11 @@
handlerState.setCommand(BlazeCommandName.fromString("command"));
assertThat(
BlazeJavaRunProfileState.getBlazeCommand(
- project, configuration, ProjectViewSet.builder().build(), true /* debug */)
+ project,
+ configuration,
+ ProjectViewSet.builder().build(),
+ ImmutableList.of(),
+ true /* debug */)
.toList())
.isEqualTo(
ImmutableList.of(
diff --git a/java/tests/unittests/com/google/idea/blaze/java/run/producers/BlazeJUnitTestFilterFlagsTest.java b/java/tests/unittests/com/google/idea/blaze/java/run/producers/BlazeJUnitTestFilterFlagsTest.java
new file mode 100644
index 0000000..d5d2cde
--- /dev/null
+++ b/java/tests/unittests/com/google/idea/blaze/java/run/producers/BlazeJUnitTestFilterFlagsTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright 2016 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.idea.blaze.java.run.producers;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import com.google.common.collect.ImmutableList;
+import com.google.idea.blaze.base.BlazeTestCase;
+import com.google.idea.blaze.java.run.producers.BlazeJUnitTestFilterFlags.JUnitVersion;
+import com.google.idea.common.experiments.ExperimentService;
+import com.google.idea.common.experiments.MockExperimentService;
+import org.jetbrains.annotations.NotNull;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.junit.runners.JUnit4;
+
+/** Unit tests for {@link BlazeJUnitTestFilterFlags}. */
+@RunWith(JUnit4.class)
+public class BlazeJUnitTestFilterFlagsTest extends BlazeTestCase {
+
+ @Override
+ protected void initTest(
+ @NotNull Container applicationServices, @NotNull Container projectServices) {
+ ExperimentService experimentService = new MockExperimentService();
+ applicationServices.register(ExperimentService.class, experimentService);
+ }
+
+ @Test
+ public void testSingleJUnit4ClassFilter() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName", ImmutableList.of(), JUnitVersion.JUNIT_4, false))
+ .isEqualTo("com.google.idea.ClassName#");
+ }
+
+ @Test
+ public void testSingleJUnit3ClassFilter() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName", ImmutableList.of(), JUnitVersion.JUNIT_3, false))
+ .isEqualTo("com.google.idea.ClassName");
+ }
+
+ @Test
+ public void testParameterizedIgnoredForSingleClass() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName", ImmutableList.of(), JUnitVersion.JUNIT_4, true))
+ .isEqualTo("com.google.idea.ClassName#");
+ }
+
+ @Test
+ public void testJUnit4ClassAndSingleMethod() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName",
+ ImmutableList.of("testMethod1"),
+ JUnitVersion.JUNIT_4,
+ false))
+ .isEqualTo("com.google.idea.ClassName#testMethod1$");
+ }
+
+ @Test
+ public void testJUnit3ClassAndSingleMethod() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName",
+ ImmutableList.of("testMethod1"),
+ JUnitVersion.JUNIT_3,
+ false))
+ .isEqualTo("com.google.idea.ClassName#testMethod1");
+ }
+
+ @Test
+ public void testJUnit4ClassAndMultipleMethods() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName",
+ ImmutableList.of("testMethod1", "testMethod2"),
+ JUnitVersion.JUNIT_4,
+ false))
+ .isEqualTo("com.google.idea.ClassName#(testMethod1|testMethod2)$");
+ }
+
+ @Test
+ public void testJUnit4ParametrizedClassAndMultipleMethods() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName",
+ ImmutableList.of("testMethod1", "testMethod2"),
+ JUnitVersion.JUNIT_4,
+ true))
+ .isEqualTo("com.google.idea.ClassName#(testMethod1|testMethod2)(\\[.+\\])?$");
+ }
+
+ @Test
+ public void testJUnit3ClassAndMultipleMethods() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName",
+ ImmutableList.of("testMethod1", "testMethod2"),
+ JUnitVersion.JUNIT_3,
+ false))
+ .isEqualTo("com.google.idea.ClassName#testMethod1,testMethod2");
+ }
+
+ @Test
+ public void testParameterizedIgnoredForJUnit3() {
+ assertThat(
+ BlazeJUnitTestFilterFlags.testFilterForClassAndMethods(
+ "com.google.idea.ClassName",
+ ImmutableList.of("testMethod1", "testMethod2"),
+ JUnitVersion.JUNIT_3,
+ true))
+ .isEqualTo("com.google.idea.ClassName#testMethod1,testMethod2");
+ }
+}
diff --git a/plugin_dev/BUILD b/plugin_dev/BUILD
index 48eb552..1c56953 100644
--- a/plugin_dev/BUILD
+++ b/plugin_dev/BUILD
@@ -9,6 +9,7 @@
"//intellij_platform_sdk:devkit",
"//intellij_platform_sdk:plugin_api",
"//java",
+ "//sdkcompat",
"@jsr305_annotations//jar",
],
)
diff --git a/plugin_dev/src/com/google/idea/blaze/plugin/run/BlazeIntellijPluginConfiguration.java b/plugin_dev/src/com/google/idea/blaze/plugin/run/BlazeIntellijPluginConfiguration.java
index 00cbccb..a68f89b 100644
--- a/plugin_dev/src/com/google/idea/blaze/plugin/run/BlazeIntellijPluginConfiguration.java
+++ b/plugin_dev/src/com/google/idea/blaze/plugin/run/BlazeIntellijPluginConfiguration.java
@@ -35,6 +35,8 @@
import com.google.idea.blaze.base.projectview.ProjectViewSet;
import com.google.idea.blaze.base.run.BlazeConfigurationNameBuilder;
import com.google.idea.blaze.base.run.BlazeRunConfiguration;
+import com.google.idea.blaze.base.run.state.RunConfigurationFlagsState;
+import com.google.idea.blaze.base.run.state.RunConfigurationStateEditor;
import com.google.idea.blaze.base.run.targetfinder.TargetFinder;
import com.google.idea.blaze.base.settings.Blaze;
import com.google.idea.blaze.base.sync.data.BlazeProjectDataManager;
@@ -47,6 +49,7 @@
import com.intellij.execution.configurations.JavaCommandLineState;
import com.intellij.execution.configurations.JavaParameters;
import com.intellij.execution.configurations.LocatableConfigurationBase;
+import com.intellij.execution.configurations.LogFileOptions;
import com.intellij.execution.configurations.ModuleRunConfiguration;
import com.intellij.execution.configurations.ParametersList;
import com.intellij.execution.configurations.RunProfileState;
@@ -75,13 +78,15 @@
import com.intellij.openapi.util.WriteExternalException;
import com.intellij.ui.ListCellRendererWrapper;
import com.intellij.ui.RawCommandLineEditor;
+import com.intellij.ui.components.JBCheckBox;
import com.intellij.util.PlatformUtils;
-import com.intellij.util.execution.ParametersListUtil;
import java.awt.BorderLayout;
import java.io.File;
import java.io.IOException;
import java.nio.file.Files;
+import java.nio.file.Paths;
import java.nio.file.StandardCopyOption;
+import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import javax.annotation.Nullable;
@@ -89,7 +94,6 @@
import javax.swing.JComponent;
import javax.swing.JLabel;
import javax.swing.JList;
-import javax.swing.JTextArea;
import org.jdom.Element;
/**
@@ -105,16 +109,20 @@
private static final String SDK_ATTR = "blaze-plugin-sdk";
private static final String VM_PARAMS_ATTR = "blaze-vm-params";
private static final String PROGRAM_PARAMS_ATTR = "blaze-program-params";
+ private static final String KEEP_IN_SYNC_TAG = "keep-in-sync";
private final String buildSystem;
@Nullable private Label target;
- private ImmutableList<String> blazeFlags = ImmutableList.of();
- private ImmutableList<String> exeFlags = ImmutableList.of();
+ private final RunConfigurationFlagsState blazeFlags;
+ private final RunConfigurationFlagsState exeFlags;
@Nullable private Sdk pluginSdk;
@Nullable String vmParameters;
@Nullable private String programParameters;
+ // for keeping imported configurations in sync with their source XML
+ @Nullable private Boolean keepInSync = null;
+
public BlazeIntellijPluginConfiguration(
Project project,
ConfigurationFactory factory,
@@ -129,6 +137,19 @@
if (initialTarget != null) {
target = initialTarget.key.label;
}
+ blazeFlags = new RunConfigurationFlagsState(USER_BLAZE_FLAG_TAG, buildSystem + " flags:");
+ exeFlags = new RunConfigurationFlagsState(USER_EXE_FLAG_TAG, "Executable flags:");
+ }
+
+ @Override
+ public void setKeepInSync(@Nullable Boolean keepInSync) {
+ this.keepInSync = keepInSync;
+ }
+
+ @Override
+ @Nullable
+ public Boolean getKeepInSync() {
+ return keepInSync;
}
@Override
@@ -147,6 +168,19 @@
}
}
+ @Override
+ public ArrayList<LogFileOptions> getAllLogFiles() {
+ ArrayList<LogFileOptions> result = new ArrayList<>();
+ if (pluginSdk == null) {
+ return result;
+ }
+ String sandboxHome = IdeaJdkHelper.getSandboxHome(pluginSdk);
+ String logFile = Paths.get(sandboxHome, "system", "log", "idea.log").toString();
+ LogFileOptions logFileOptions = new LogFileOptions("idea.log", logFile, true, true, true);
+ result.add(logFileOptions);
+ return result;
+ }
+
private ImmutableList<File> findPluginJars() throws ExecutionException {
BlazeProjectData blazeProjectData =
BlazeProjectDataManager.getInstance(getProject()).getBlazeProjectData();
@@ -353,8 +387,8 @@
} else {
target = null;
}
- blazeFlags = loadUserFlags(element, USER_BLAZE_FLAG_TAG);
- exeFlags = loadUserFlags(element, USER_EXE_FLAG_TAG);
+ blazeFlags.readExternal(element);
+ exeFlags.readExternal(element);
String sdkName = element.getAttributeValue(SDK_ATTR);
if (!Strings.isNullOrEmpty(sdkName)) {
@@ -362,25 +396,9 @@
}
vmParameters = Strings.emptyToNull(element.getAttributeValue(VM_PARAMS_ATTR));
programParameters = Strings.emptyToNull(element.getAttributeValue(PROGRAM_PARAMS_ATTR));
- }
- private static ImmutableList<String> loadUserFlags(Element root, String tag) {
- ImmutableList.Builder<String> flagsBuilder = ImmutableList.builder();
- for (Element e : root.getChildren(tag)) {
- String flag = e.getTextTrim();
- if (flag != null && !flag.isEmpty()) {
- flagsBuilder.add(flag);
- }
- }
- return flagsBuilder.build();
- }
-
- private static void saveUserFlags(Element root, List<String> flags, String tag) {
- for (String flag : flags) {
- Element child = new Element(tag);
- child.setText(flag);
- root.addContent(child);
- }
+ String keepInSyncString = element.getAttributeValue(KEEP_IN_SYNC_TAG);
+ keepInSync = keepInSyncString != null ? Boolean.parseBoolean(keepInSyncString) : null;
}
@Override
@@ -392,8 +410,8 @@
targetElement.setText(target.toString());
element.addContent(targetElement);
}
- saveUserFlags(element, blazeFlags, USER_BLAZE_FLAG_TAG);
- saveUserFlags(element, exeFlags, USER_EXE_FLAG_TAG);
+ blazeFlags.writeExternal(element);
+ exeFlags.writeExternal(element);
if (pluginSdk != null) {
element.setAttribute(SDK_ATTR, pluginSdk.getName());
}
@@ -403,6 +421,9 @@
if (programParameters != null) {
element.setAttribute(PROGRAM_PARAMS_ATTR, programParameters);
}
+ if (keepInSync != null) {
+ element.setAttribute(KEEP_IN_SYNC_TAG, Boolean.toString(keepInSync));
+ }
}
@Override
@@ -410,11 +431,12 @@
final BlazeIntellijPluginConfiguration configuration =
(BlazeIntellijPluginConfiguration) super.clone();
configuration.target = target;
- configuration.blazeFlags = blazeFlags;
- configuration.exeFlags = exeFlags;
+ configuration.blazeFlags.setFlags(blazeFlags.getFlags());
+ configuration.exeFlags.setFlags(exeFlags.getFlags());
configuration.pluginSdk = pluginSdk;
configuration.vmParameters = vmParameters;
configuration.programParameters = programParameters;
+ configuration.keepInSync = keepInSync;
return configuration;
}
@@ -423,8 +445,8 @@
BlazeCommand.builder(Blaze.getBuildSystem(getProject()), BlazeCommandName.BUILD)
.addTargets(getTarget())
.addBlazeFlags(BlazeFlags.buildFlags(project, projectViewSet))
- .addBlazeFlags(blazeFlags)
- .addExeFlags(exeFlags);
+ .addBlazeFlags(blazeFlags.getFlags())
+ .addExeFlags(exeFlags.getFlags());
return command.build();
}
@@ -436,7 +458,8 @@
for (TargetIdeInfo target : javaTargets) {
javaLabels.add(target.key.label);
}
- return new BlazeIntellijPluginConfigurationSettingsEditor(buildSystem, javaLabels);
+ return new BlazeIntellijPluginConfigurationSettingsEditor(
+ javaLabels, blazeFlags.getEditor(getProject()), exeFlags.getEditor(getProject()));
}
@Override
@@ -456,21 +479,23 @@
@VisibleForTesting
static class BlazeIntellijPluginConfigurationSettingsEditor
extends SettingsEditor<BlazeIntellijPluginConfiguration> {
- private final String buildSystemName;
- private final ComboBox targetCombo;
- private final JTextArea blazeFlagsField = new JTextArea(5, 0);
- private final JTextArea exeFlagsField = new JTextArea(5, 0);
+ private final ComboBox<Label> targetCombo;
+ private final RunConfigurationStateEditor blazeFlagsEditor;
+ private final RunConfigurationStateEditor exeFlagsEditor;
private final JdkComboBox sdkCombo;
private final LabeledComponent<RawCommandLineEditor> vmParameters = new LabeledComponent<>();
private final LabeledComponent<RawCommandLineEditor> programParameters =
new LabeledComponent<>();
+ private final JBCheckBox keepInSyncCheckBox;
public BlazeIntellijPluginConfigurationSettingsEditor(
- String buildSystemName, List<Label> javaLabels) {
- this.buildSystemName = buildSystemName;
+ List<Label> javaLabels,
+ RunConfigurationStateEditor blazeFlagsEditor,
+ RunConfigurationStateEditor exeFlagsEditor) {
targetCombo =
- new ComboBox(
- new DefaultComboBoxModel(Ordering.usingToString().sortedCopy(javaLabels).toArray()));
+ new ComboBox<>(
+ new DefaultComboBoxModel<>(
+ Ordering.usingToString().sortedCopy(javaLabels).toArray(new Label[0])));
targetCombo.setRenderer(
new ListCellRendererWrapper<Label>() {
@Override
@@ -479,18 +504,35 @@
setText(value == null ? null : value.toString());
}
});
-
+ this.blazeFlagsEditor = blazeFlagsEditor;
+ this.exeFlagsEditor = exeFlagsEditor;
ProjectSdksModel sdksModel = new ProjectSdksModel();
sdksModel.reset(null);
sdkCombo = new JdkComboBox(sdksModel, IdeaJdkHelper::isIdeaJdkType);
+
+ keepInSyncCheckBox = new JBCheckBox("Keep in sync with source XML");
+ keepInSyncCheckBox.addItemListener(e -> updateEnabledStatus());
+ }
+
+ private void updateEnabledStatus() {
+ setEnabled(!keepInSyncCheckBox.isVisible() || !keepInSyncCheckBox.isSelected());
+ }
+
+ private void setEnabled(boolean enabled) {
+ targetCombo.setEnabled(enabled);
+ sdkCombo.setEnabled(enabled);
+ vmParameters.getComponent().setEnabled(enabled);
+ programParameters.getComponent().setEnabled(enabled);
+ blazeFlagsEditor.setComponentEnabled(enabled);
+ exeFlagsEditor.setComponentEnabled(enabled);
}
@VisibleForTesting
@Override
public void resetEditorFrom(BlazeIntellijPluginConfiguration s) {
targetCombo.setSelectedItem(s.getTarget());
- blazeFlagsField.setText(ParametersListUtil.join(s.blazeFlags));
- exeFlagsField.setText(ParametersListUtil.join(s.exeFlags));
+ blazeFlagsEditor.resetEditorFrom(s.blazeFlags);
+ exeFlagsEditor.resetEditorFrom(s.exeFlags);
if (s.pluginSdk != null) {
sdkCombo.setSelectedJdk(s.pluginSdk);
} else {
@@ -502,6 +544,10 @@
if (s.programParameters != null) {
programParameters.getComponent().setText(s.programParameters);
}
+ keepInSyncCheckBox.setVisible(s.keepInSync != null);
+ if (s.keepInSync != null) {
+ keepInSyncCheckBox.setSelected(s.keepInSync);
+ }
}
@VisibleForTesting
@@ -512,15 +558,12 @@
} catch (ClassCastException e) {
throw new ConfigurationException("Invalid label specified.");
}
- s.blazeFlags =
- ImmutableList.copyOf(
- ParametersListUtil.parse(Strings.nullToEmpty(blazeFlagsField.getText())));
- s.exeFlags =
- ImmutableList.copyOf(
- ParametersListUtil.parse(Strings.nullToEmpty(exeFlagsField.getText())));
+ blazeFlagsEditor.applyEditorTo(s.blazeFlags);
+ exeFlagsEditor.applyEditorTo(s.exeFlags);
s.pluginSdk = sdkCombo.getSelectedJdk();
s.vmParameters = vmParameters.getComponent().getText();
s.programParameters = programParameters.getComponent().getText();
+ s.keepInSync = keepInSyncCheckBox.isVisible() ? keepInSyncCheckBox.isSelected() : null;
}
@Override
@@ -544,10 +587,9 @@
vmParameters.getComponent(),
programParameters.getLabel(),
programParameters.getComponent(),
- new JLabel(buildSystemName + " flags:"),
- blazeFlagsField,
- new JLabel("Executable flags:"),
- exeFlagsField);
+ blazeFlagsEditor.createComponent(),
+ exeFlagsEditor.createComponent(),
+ keepInSyncCheckBox);
}
}
}
diff --git a/plugin_dev/src/com/google/idea/blaze/plugin/sync/IntellijPluginSyncPlugin.java b/plugin_dev/src/com/google/idea/blaze/plugin/sync/IntellijPluginSyncPlugin.java
index 34b06df..e2eeb8e 100644
--- a/plugin_dev/src/com/google/idea/blaze/plugin/sync/IntellijPluginSyncPlugin.java
+++ b/plugin_dev/src/com/google/idea/blaze/plugin/sync/IntellijPluginSyncPlugin.java
@@ -18,6 +18,7 @@
import com.google.common.collect.ImmutableList;
import com.google.common.collect.ImmutableSet;
import com.google.idea.blaze.base.model.BlazeProjectData;
+import com.google.idea.blaze.base.model.BlazeVersionData;
import com.google.idea.blaze.base.model.primitives.LanguageClass;
import com.google.idea.blaze.base.model.primitives.WorkspaceType;
import com.google.idea.blaze.base.projectview.ProjectViewSet;
@@ -27,13 +28,13 @@
import com.google.idea.blaze.java.sync.JavaLanguageLevelHelper;
import com.google.idea.blaze.java.sync.model.BlazeJavaSyncData;
import com.google.idea.blaze.java.sync.projectstructure.JavaSourceFolderProvider;
+import com.google.idea.sdkcompat.transactions.Transactions;
import com.intellij.openapi.application.ApplicationManager;
import com.intellij.openapi.module.ModuleType;
import com.intellij.openapi.module.StdModuleTypes;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.LanguageLevelProjectExtension;
import com.intellij.pom.java.LanguageLevel;
-import com.intellij.util.ui.UIUtil;
import java.util.Set;
import javax.annotation.Nullable;
@@ -79,6 +80,7 @@
Project project,
BlazeContext context,
ProjectViewSet projectViewSet,
+ BlazeVersionData blazeVersionData,
BlazeProjectData blazeProjectData) {
if (!blazeProjectData.workspaceLanguageSettings.isWorkspaceType(
WorkspaceType.INTELLIJ_PLUGIN)) {
@@ -90,15 +92,14 @@
projectViewSet, blazeProjectData, LanguageLevel.JDK_1_7);
// Leave the SDK, but set the language level
- UIUtil.invokeAndWaitIfNeeded(
- (Runnable)
- () ->
- ApplicationManager.getApplication()
- .runWriteAction(
- () -> {
- LanguageLevelProjectExtension ext =
- LanguageLevelProjectExtension.getInstance(project);
- ext.setLanguageLevel(javaLanguageLevel);
- }));
+ Transactions.submitTransactionAndWait(
+ () ->
+ ApplicationManager.getApplication()
+ .runWriteAction(
+ () -> {
+ LanguageLevelProjectExtension ext =
+ LanguageLevelProjectExtension.getInstance(project);
+ ext.setLanguageLevel(javaLanguageLevel);
+ }));
}
}
diff --git a/proto_deps/proto_deps.jar b/proto_deps/proto_deps.jar
index 1a140af..6f79519 100755
--- a/proto_deps/proto_deps.jar
+++ b/proto_deps/proto_deps.jar
Binary files differ
diff --git a/sdkcompat/BUILD b/sdkcompat/BUILD
new file mode 100644
index 0000000..ce19ce5
--- /dev/null
+++ b/sdkcompat/BUILD
@@ -0,0 +1,25 @@
+# Description: Indirections for SDK changes to the underlying platform library.
+
+licenses(["notice"]) # Apache 2.0
+
+load("//intellij_platform_sdk:build_defs.bzl", "select_for_plugin_api")
+
+java_library(
+ name = "sdkcompat",
+ srcs = select_for_plugin_api({
+ "android-studio-145.1617.8": glob(["v145/**"]),
+ "android-studio-2.3.0.3": glob(["v162/**"]),
+ "android-studio-2.3.0.4": glob(["v162/**"]),
+ "intellij-2016.3.1": glob(["v163/**"]),
+ "intellij-162.2032.8": glob(["v162/**"]),
+ "clion-162.1967.7": glob(
+ ["v162/**"],
+ exclude = ["v162/com/google/idea/sdkcompat/debugger/**"],
+ ),
+ }),
+ visibility = ["//visibility:public"],
+ deps = [
+ "//intellij_platform_sdk:plugin_api",
+ "@jsr305_annotations//jar",
+ ],
+)
diff --git a/sdkcompat/v145/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java b/sdkcompat/v145/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java
new file mode 100644
index 0000000..6051cc9
--- /dev/null
+++ b/sdkcompat/v145/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java
@@ -0,0 +1,6 @@
+package com.google.idea.sdkcompat.codestyle;
+
+import com.intellij.psi.codeStyle.CodeStyleManager;
+
+/** Adapter to extend two bridge different IntelliJ SDK versions. */
+public abstract class CodeStyleManagerSdkCompatAdapter extends CodeStyleManager {}
diff --git a/sdkcompat/v145/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java b/sdkcompat/v145/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java
new file mode 100644
index 0000000..6dfc995
--- /dev/null
+++ b/sdkcompat/v145/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java
@@ -0,0 +1,25 @@
+package com.google.idea.sdkcompat.debugger;
+
+import com.intellij.debugger.impl.GenericDebuggerRunner;
+import com.intellij.execution.ExecutionException;
+import com.intellij.execution.configurations.RemoteConnection;
+import com.intellij.execution.configurations.RunProfileState;
+import com.intellij.execution.runners.ExecutionEnvironment;
+import com.intellij.execution.ui.RunContentDescriptor;
+import javax.annotation.Nullable;
+
+/** SDK compatibility for {@link GenericDebuggerRunner}. */
+public class GenericDebuggerRunnerSdkCompatAdapter extends GenericDebuggerRunner {
+
+ @Nullable
+ protected RunContentDescriptor attachVirtualMachine(
+ RunProfileState state,
+ ExecutionEnvironment env,
+ RemoteConnection connection,
+ long pollTimeout)
+ throws ExecutionException {
+ // no timeout available until 2016.2 onwards
+ return super.attachVirtualMachine(
+ state, env, connection, pollTimeout != 0 /* pollConnection */);
+ }
+}
diff --git a/sdkcompat/v145/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java b/sdkcompat/v145/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java
new file mode 100644
index 0000000..c4bd9a7
--- /dev/null
+++ b/sdkcompat/v145/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java
@@ -0,0 +1,13 @@
+package com.google.idea.sdkcompat.smrunner;
+
+import com.intellij.execution.testframework.sm.runner.events.TestFailedEvent;
+import javax.annotation.Nullable;
+
+/** Handles SM-runner methods which have changed between our supported versions. */
+public class SmRunnerCompatUtils {
+
+ public static TestFailedEvent getTestFailedEvent(
+ String name, @Nullable String message, @Nullable String content, long duration) {
+ return new TestFailedEvent(name, -1, message, content, true, null, null, null, duration);
+ }
+}
diff --git a/sdkcompat/v145/com/google/idea/sdkcompat/transactions/Transactions.java b/sdkcompat/v145/com/google/idea/sdkcompat/transactions/Transactions.java
new file mode 100644
index 0000000..94ab905
--- /dev/null
+++ b/sdkcompat/v145/com/google/idea/sdkcompat/transactions/Transactions.java
@@ -0,0 +1,16 @@
+package com.google.idea.sdkcompat.transactions;
+
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.ModalityState;
+
+/** Created by tomlu on 12/22/16. */
+public class Transactions {
+ public static void submitTransactionAndWait(Runnable runnable) {
+ ApplicationManager.getApplication().invokeAndWait(runnable, ModalityState.any());
+ }
+
+ public static void submitTransaction(Disposable disposable, Runnable runnable) {
+ ApplicationManager.getApplication().invokeLater(runnable);
+ }
+}
diff --git a/sdkcompat/v145/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java b/sdkcompat/v145/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java
new file mode 100644
index 0000000..df055ea
--- /dev/null
+++ b/sdkcompat/v145/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java
@@ -0,0 +1,12 @@
+package com.google.idea.sdkcompat.vcs;
+
+import com.intellij.openapi.vcs.changes.ChangeListManager;
+import com.intellij.util.continuation.ContinuationPause;
+
+/** SDK adapter for change list interface. */
+public abstract class ChangeListManagerSdkCompatAdapter extends ChangeListManager {
+ @Override
+ public void freeze(ContinuationPause context, String reason) {
+ throw new UnsupportedOperationException("ChangeListManager#freeze()");
+ }
+}
diff --git a/sdkcompat/v162/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java b/sdkcompat/v162/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java
new file mode 100644
index 0000000..6051cc9
--- /dev/null
+++ b/sdkcompat/v162/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java
@@ -0,0 +1,6 @@
+package com.google.idea.sdkcompat.codestyle;
+
+import com.intellij.psi.codeStyle.CodeStyleManager;
+
+/** Adapter to extend two bridge different IntelliJ SDK versions. */
+public abstract class CodeStyleManagerSdkCompatAdapter extends CodeStyleManager {}
diff --git a/sdkcompat/v162/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java b/sdkcompat/v162/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java
new file mode 100644
index 0000000..ed822b3
--- /dev/null
+++ b/sdkcompat/v162/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java
@@ -0,0 +1,6 @@
+package com.google.idea.sdkcompat.debugger;
+
+import com.intellij.debugger.impl.GenericDebuggerRunner;
+
+/** SDK compatibility for {@link GenericDebuggerRunner}. */
+public class GenericDebuggerRunnerSdkCompatAdapter extends GenericDebuggerRunner {}
diff --git a/sdkcompat/v162/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java b/sdkcompat/v162/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java
new file mode 100644
index 0000000..1e9b474
--- /dev/null
+++ b/sdkcompat/v162/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java
@@ -0,0 +1,13 @@
+package com.google.idea.sdkcompat.smrunner;
+
+import com.intellij.execution.testframework.sm.runner.events.TestFailedEvent;
+import javax.annotation.Nullable;
+
+/** Handles SM-runner methods which have changed between our supported versions. */
+public class SmRunnerCompatUtils {
+
+ public static TestFailedEvent getTestFailedEvent(
+ String name, @Nullable String message, @Nullable String content, long duration) {
+ return new TestFailedEvent(name, null, message, content, true, null, null, null, duration);
+ }
+}
diff --git a/sdkcompat/v162/com/google/idea/sdkcompat/transactions/Transactions.java b/sdkcompat/v162/com/google/idea/sdkcompat/transactions/Transactions.java
new file mode 100644
index 0000000..94ab905
--- /dev/null
+++ b/sdkcompat/v162/com/google/idea/sdkcompat/transactions/Transactions.java
@@ -0,0 +1,16 @@
+package com.google.idea.sdkcompat.transactions;
+
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.ApplicationManager;
+import com.intellij.openapi.application.ModalityState;
+
+/** Created by tomlu on 12/22/16. */
+public class Transactions {
+ public static void submitTransactionAndWait(Runnable runnable) {
+ ApplicationManager.getApplication().invokeAndWait(runnable, ModalityState.any());
+ }
+
+ public static void submitTransaction(Disposable disposable, Runnable runnable) {
+ ApplicationManager.getApplication().invokeLater(runnable);
+ }
+}
diff --git a/sdkcompat/v162/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java b/sdkcompat/v162/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java
new file mode 100644
index 0000000..df055ea
--- /dev/null
+++ b/sdkcompat/v162/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java
@@ -0,0 +1,12 @@
+package com.google.idea.sdkcompat.vcs;
+
+import com.intellij.openapi.vcs.changes.ChangeListManager;
+import com.intellij.util.continuation.ContinuationPause;
+
+/** SDK adapter for change list interface. */
+public abstract class ChangeListManagerSdkCompatAdapter extends ChangeListManager {
+ @Override
+ public void freeze(ContinuationPause context, String reason) {
+ throw new UnsupportedOperationException("ChangeListManager#freeze()");
+ }
+}
diff --git a/sdkcompat/v163/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java b/sdkcompat/v163/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java
new file mode 100644
index 0000000..33d3ad4
--- /dev/null
+++ b/sdkcompat/v163/com/google/idea/sdkcompat/codestyle/CodeStyleManagerSdkCompatAdapter.java
@@ -0,0 +1,22 @@
+package com.google.idea.sdkcompat.codestyle;
+
+import com.intellij.openapi.util.TextRange;
+import com.intellij.psi.PsiFile;
+import com.intellij.psi.codeStyle.ChangedRangesInfo;
+import com.intellij.psi.codeStyle.CodeStyleManager;
+import com.intellij.util.IncorrectOperationException;
+import java.util.ArrayList;
+import java.util.List;
+import org.jetbrains.annotations.NotNull;
+
+/** Adapter to extend two bridge different IntelliJ SDK versions. */
+public abstract class CodeStyleManagerSdkCompatAdapter extends CodeStyleManager {
+ @Override
+ public void reformatTextWithContext(@NotNull PsiFile file, @NotNull ChangedRangesInfo info)
+ throws IncorrectOperationException {
+ List<TextRange> ranges = new ArrayList<>();
+ ranges.addAll(info.insertedRanges);
+ ranges.addAll(info.allChangedRanges);
+ this.reformatTextWithContext(file, ranges);
+ }
+}
diff --git a/sdkcompat/v163/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java b/sdkcompat/v163/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java
new file mode 100644
index 0000000..ed822b3
--- /dev/null
+++ b/sdkcompat/v163/com/google/idea/sdkcompat/debugger/GenericDebuggerRunnerSdkCompatAdapter.java
@@ -0,0 +1,6 @@
+package com.google.idea.sdkcompat.debugger;
+
+import com.intellij.debugger.impl.GenericDebuggerRunner;
+
+/** SDK compatibility for {@link GenericDebuggerRunner}. */
+public class GenericDebuggerRunnerSdkCompatAdapter extends GenericDebuggerRunner {}
diff --git a/sdkcompat/v163/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java b/sdkcompat/v163/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java
new file mode 100644
index 0000000..1e9b474
--- /dev/null
+++ b/sdkcompat/v163/com/google/idea/sdkcompat/smrunner/SmRunnerCompatUtils.java
@@ -0,0 +1,13 @@
+package com.google.idea.sdkcompat.smrunner;
+
+import com.intellij.execution.testframework.sm.runner.events.TestFailedEvent;
+import javax.annotation.Nullable;
+
+/** Handles SM-runner methods which have changed between our supported versions. */
+public class SmRunnerCompatUtils {
+
+ public static TestFailedEvent getTestFailedEvent(
+ String name, @Nullable String message, @Nullable String content, long duration) {
+ return new TestFailedEvent(name, null, message, content, true, null, null, null, duration);
+ }
+}
diff --git a/sdkcompat/v163/com/google/idea/sdkcompat/transactions/Transactions.java b/sdkcompat/v163/com/google/idea/sdkcompat/transactions/Transactions.java
new file mode 100644
index 0000000..8862aa8
--- /dev/null
+++ b/sdkcompat/v163/com/google/idea/sdkcompat/transactions/Transactions.java
@@ -0,0 +1,15 @@
+package com.google.idea.sdkcompat.transactions;
+
+import com.intellij.openapi.Disposable;
+import com.intellij.openapi.application.TransactionGuard;
+
+/** SDK adapter to use transaction guards. */
+public class Transactions {
+ public static void submitTransactionAndWait(Runnable runnable) {
+ TransactionGuard.getInstance().submitTransactionAndWait(runnable);
+ }
+
+ public static void submitTransaction(Disposable disposable, Runnable runnable) {
+ TransactionGuard.submitTransaction(disposable, runnable);
+ }
+}
diff --git a/sdkcompat/v163/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java b/sdkcompat/v163/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java
new file mode 100644
index 0000000..1e525c1
--- /dev/null
+++ b/sdkcompat/v163/com/google/idea/sdkcompat/vcs/ChangeListManagerSdkCompatAdapter.java
@@ -0,0 +1,6 @@
+package com.google.idea.sdkcompat.vcs;
+
+import com.intellij.openapi.vcs.changes.ChangeListManager;
+
+/** SDK adapter to for changelist interface. */
+public abstract class ChangeListManagerSdkCompatAdapter extends ChangeListManager {}
diff --git a/version.bzl b/version.bzl
index 0f144e5..1bcca22 100644
--- a/version.bzl
+++ b/version.bzl
@@ -1,3 +1,3 @@
"""Version of the blaze plugin."""
-VERSION = "2016.12.05.6"
+VERSION = "2017.01.09.1"
