Removed static dependency to the Application from the 'sync project changes' code. The reason is to avoid global setup changes during the tests processing
serviceImplementation="org.jetbrains.plugins.gradle.diff.GradleProjectStructureChangesCalculator"/>
<applicationService serviceImplementation="org.jetbrains.plugins.gradle.diff.GradleModuleStructureChangesCalculator"/>
<applicationService serviceImplementation="org.jetbrains.plugins.gradle.diff.GradleLibraryDependencyStructureChangesCalculator"/>
- <applicationService serviceInterface="org.jetbrains.plugins.gradle.diff.GradleProjectStructureHelper"
+ <applicationService serviceInterface="org.jetbrains.plugins.gradle.diff.PlatformFacade"
serviceImplementation="org.jetbrains.plugins.gradle.diff.GradleProjectStructureHelperImpl"/>
<applicationService serviceInterface="org.jetbrains.plugins.gradle.notification.GradleProgressNotificationManager"
serviceImplementation="org.jetbrains.plugins.gradle.notification.GradleProgressNotificationManagerImpl"/>
import com.intellij.openapi.wm.ex.ToolWindowManagerEx;
import com.intellij.ui.content.impl.ContentImpl;
import org.jetbrains.annotations.NotNull;
-import org.jetbrains.plugins.gradle.diff.GradleProjectStructureHelper;
+import org.jetbrains.plugins.gradle.diff.PlatformFacade;
import org.jetbrains.plugins.gradle.sync.GradleProjectStructureChangesModel;
import org.jetbrains.plugins.gradle.sync.GradleProjectStructureChangesPanel;
import org.jetbrains.plugins.gradle.ui.GradleIcons;
private static final String GRADLE_TOOL_WINDOW_ID = GradleBundle.message("gradle.name");
private final GradleProjectStructureChangesModel myChangesModel;
- private final GradleProjectStructureHelper myProjectStructureHelper;
+ private final PlatformFacade myProjectStructureHelper;
public GradleBootstrap(@NotNull Project project,
@NotNull GradleProjectStructureChangesModel changesModel,
- @NotNull GradleProjectStructureHelper projectStructureHelper) {
+ @NotNull PlatformFacade projectStructureHelper) {
super(project);
myChangesModel = changesModel;
myProjectStructureHelper = projectStructureHelper;
import com.intellij.ide.projectView.PresentationData;
import com.intellij.ide.util.treeView.NodeRenderer;
import com.intellij.openapi.application.ApplicationNamesInfo;
+import com.intellij.openapi.application.ex.ApplicationInfoEx;
import com.intellij.openapi.editor.colors.EditorColorsScheme;
import com.intellij.openapi.editor.colors.TextAttributesKey;
+import com.intellij.openapi.util.IconLoader;
import com.intellij.openapi.util.Pair;
import com.intellij.openapi.util.Ref;
import com.intellij.ui.components.JBScrollPane;
private Pair<Tree, DefaultTreeModel> init() {
myContent.removeAll();
String projectName = GradleBundle.message("gradle.settings.color.text.sample.conflict.node.name");
- DefaultMutableTreeNode root = createNode(projectName, GradleIcons.PROJECT_ICON, GradleTextAttributes.GRADLE_CHANGE_CONFLICT);
+ DefaultMutableTreeNode root = createNode(
+ projectName,
+ IconLoader.getIcon(ApplicationInfoEx.getInstanceEx().getSmallIconUrl()),
+ GradleTextAttributes.GRADLE_CHANGE_CONFLICT
+ );
String moduleName = GradleBundle.message("gradle.settings.color.text.sample.node.confirmed.name");
DefaultMutableTreeNode module = createNode(moduleName, GradleIcons.MODULE_ICON, GradleTextAttributes.GRADLE_CONFIRMED_CONFLICT);
import com.intellij.util.messages.MessageBusConnection;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
-import org.jetbrains.plugins.gradle.diff.GradleProjectStructureHelper;
+import org.jetbrains.plugins.gradle.diff.PlatformFacade;
import org.jetbrains.plugins.gradle.util.GradleBundle;
import org.jetbrains.plugins.gradle.ui.RichTextControlBuilder;
private final JPanel myContent = new JPanel(myLayout);
private final Project myProject;
- private final GradleProjectStructureHelper myProjectStructureHelper;
+ private final PlatformFacade myProjectStructureHelper;
protected GradleToolWindowPanel(@NotNull Project project,
- @Nullable GradleProjectStructureHelper projectStructureHelper,
+ @Nullable PlatformFacade projectStructureHelper,
@NotNull String place)
{
super(true);
}
@NotNull
- public GradleProjectStructureHelper getProjectStructureHelper() {
+ public PlatformFacade getProjectStructureHelper() {
return myProjectStructureHelper;
}
public class GradleModuleStructureChangesCalculator implements GradleStructureChangesCalculator<GradleModule, Module> {
private final GradleLibraryDependencyStructureChangesCalculator myLibraryDependencyCalculator;
- private final GradleProjectStructureHelper myStructureHelper;
+ private final PlatformFacade myStructureHelper;
public GradleModuleStructureChangesCalculator(@NotNull GradleLibraryDependencyStructureChangesCalculator libraryDependencyCalculator,
- @NotNull GradleProjectStructureHelper structureHelper)
+ @NotNull PlatformFacade structureHelper)
{
myLibraryDependencyCalculator = libraryDependencyCalculator;
myStructureHelper = structureHelper;
public class GradleProjectStructureChangesCalculator implements GradleStructureChangesCalculator<GradleProject, Project> {
private final GradleModuleStructureChangesCalculator myModuleChangesCalculator;
- private final GradleProjectStructureHelper myStructureHelper;
+ private final PlatformFacade myStructureHelper;
public GradleProjectStructureChangesCalculator(@NotNull GradleModuleStructureChangesCalculator moduleCalculator,
- @NotNull GradleProjectStructureHelper structureHelper) {
+ @NotNull PlatformFacade structureHelper) {
myModuleChangesCalculator = moduleCalculator;
myStructureHelper = structureHelper;
}
package org.jetbrains.plugins.gradle.diff;
+import com.intellij.openapi.application.ex.ApplicationInfoEx;
import com.intellij.openapi.module.Module;
import com.intellij.openapi.module.ModuleManager;
import com.intellij.openapi.project.Project;
import com.intellij.openapi.roots.LanguageLevelProjectExtension;
import com.intellij.openapi.roots.ModuleRootManager;
import com.intellij.openapi.roots.OrderEntry;
+import com.intellij.openapi.util.IconLoader;
import com.intellij.pom.java.LanguageLevel;
import org.jetbrains.annotations.NotNull;
+import javax.swing.*;
import java.util.Arrays;
import java.util.Collection;
* @author Denis Zhdanov
* @since 1/26/12 11:54 AM
*/
-public class GradleProjectStructureHelperImpl implements GradleProjectStructureHelper {
+public class GradleProjectStructureHelperImpl implements PlatformFacade {
@NotNull
@Override
public Collection<OrderEntry> getOrderEntries(@NotNull Module module) {
return Arrays.asList(ModuleRootManager.getInstance(module).getOrderEntries());
}
+
+ @NotNull
+ @Override
+ public Icon getProjectIcon() {
+ return IconLoader.getIcon(ApplicationInfoEx.getInstanceEx().getSmallIconUrl());
+ }
}
import com.intellij.pom.java.LanguageLevel;
import org.jetbrains.annotations.NotNull;
+import javax.swing.*;
import java.util.Collection;
/**
* That means that it's not possible to test target classes in isolation if corresponding infrastructure is not set up.
* However, we don't want to set it up if we execute a simple standalone test.
* <p/>
- * This interface is intended to encapsulate access to the underlying project infrastructure.
+ * This interface is intended to encapsulate access to the underlying IntelliJ functionality.
* <p/>
* Implementations of this interface are expected to be thread-safe.
*
* @author Denis Zhdanov
* @since 1/26/12 11:32 AM
*/
-public interface GradleProjectStructureHelper {
+public interface PlatformFacade {
@NotNull
LanguageLevel getLanguageLevel(@NotNull Project project);
@NotNull
Collection<OrderEntry> getOrderEntries(@NotNull Module module);
+
+ /**
+ * @return icon that should be used for representation project root node at the tree UI controls used by the gradle integration
+ */
+ @NotNull
+ Icon getProjectIcon();
}
package org.jetbrains.plugins.gradle.importing.wizard.adjust;
+import com.intellij.openapi.application.ex.ApplicationInfoEx;
+import com.intellij.openapi.util.IconLoader;
import com.intellij.openapi.util.Ref;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.gradle.model.*;
entity.invite(new GradleEntityVisitor() {
@Override
public void visit(@NotNull GradleProject project) {
- result.set(new GradleProjectStructureNodeDescriptor<GradleEntity>(project, project.getName(), GradleIcons.PROJECT_ICON));
+ result.set(new GradleProjectStructureNodeDescriptor<GradleEntity>(
+ project, project.getName(), IconLoader.getIcon(ApplicationInfoEx.getInstanceEx().getSmallIconUrl())
+ ));
}
@Override
import org.jetbrains.annotations.NotNull;
import org.jetbrains.plugins.gradle.config.GradleToolWindowPanel;
import org.jetbrains.plugins.gradle.diff.GradleProjectStructureChange;
-import org.jetbrains.plugins.gradle.diff.GradleProjectStructureHelper;
+import org.jetbrains.plugins.gradle.diff.PlatformFacade;
import org.jetbrains.plugins.gradle.util.GradleConstants;
import javax.swing.*;
public GradleProjectStructureChangesPanel(@NotNull Project project,
@NotNull GradleProjectStructureChangesModel model,
- @NotNull GradleProjectStructureHelper projectStructureHelper)
+ @NotNull PlatformFacade projectStructureHelper)
{
super(project, projectStructureHelper, GradleConstants.TOOL_WINDOW_TOOLBAR_PLACE);
model.addListener(new GradleProjectStructureChangeListener() {
private final TreeNode[] myNodeHolder = new TreeNode[1];
private final int[] myIndexHolder = new int[1];
- private final Project myProject;
- private final GradleProjectStructureHelper myProjectStructureHelper;
+ private final Project myProject;
+ private final PlatformFacade myPlatformFacade;
- public GradleProjectStructureTreeModel(@NotNull Project project, @NotNull GradleProjectStructureHelper projectStructureHelper) {
+ public GradleProjectStructureTreeModel(@NotNull Project project, @NotNull PlatformFacade platformFacade) {
super(null);
myProject = project;
- myProjectStructureHelper = projectStructureHelper;
+ myPlatformFacade = platformFacade;
rebuild();
}
myModules.clear();
DefaultMutableTreeNode root = new DefaultMutableTreeNode(buildDescriptor(getProject()));
- final Collection<Module> modules = myProjectStructureHelper.getModules(getProject());
+ final Collection<Module> modules = myPlatformFacade.getModules(getProject());
RootPolicy<LibraryOrderEntry> policy = new RootPolicy<LibraryOrderEntry>() {
@Override
public LibraryOrderEntry visitLibraryOrderEntry(LibraryOrderEntry libraryOrderEntry, LibraryOrderEntry value) {
final DefaultMutableTreeNode moduleNode = new DefaultMutableTreeNode(buildDescriptor(module));
myModules.put(module.getName(), moduleNode); // Assuming that module names are unique.
List<LibraryOrderEntry> libraryDependencies = new ArrayList<LibraryOrderEntry>();
- for (OrderEntry orderEntry : myProjectStructureHelper.getOrderEntries(module)) {
+ for (OrderEntry orderEntry : myPlatformFacade.getOrderEntries(module)) {
final LibraryOrderEntry libraryDependency = orderEntry.accept(policy, null);
if (libraryDependency != null && !StringUtil.isEmpty(libraryDependency.getLibraryName())) {
libraryDependencies.add(libraryDependency);
return new GradleProjectStructureNodeDescriptor<Named>(entity, entity.getName(), icon);
}
- private static GradleProjectStructureNodeDescriptor<Project> buildDescriptor(@NotNull Project project) {
- return new GradleProjectStructureNodeDescriptor<Project>(project, project.getName(), GradleIcons.PROJECT_ICON);
+ private GradleProjectStructureNodeDescriptor<Project> buildDescriptor(@NotNull Project project) {
+ return new GradleProjectStructureNodeDescriptor<Project>(project, project.getName(), myPlatformFacade.getProjectIcon());
}
private static GradleProjectStructureNodeDescriptor<Module> buildDescriptor(@NotNull Module module) {
package org.jetbrains.plugins.gradle.ui;
-import com.intellij.openapi.application.ex.ApplicationInfoEx;
import com.intellij.openapi.util.IconLoader;
import javax.swing.*;
public static final Icon GRADLE_ICON = IconLoader.getIcon("/icons/gradle.png");
public static final Icon LIB_ICON = IconLoader.getIcon("/nodes/ppLib.png");
- public static final Icon PROJECT_ICON = IconLoader.getIcon(ApplicationInfoEx.getInstanceEx().getSmallIconUrl());
public static final Icon MODULE_ICON = IconLoader.getIcon("/nodes/ModuleOpen.png");
public static final Icon CONTENT_ROOT_ICON = IconLoader.getIcon("/modules/addContentEntry.png");
import com.intellij.openapi.Disposable
-import com.intellij.openapi.application.Application
-import com.intellij.openapi.application.ApplicationManager
-import com.intellij.openapi.application.ex.ApplicationInfoEx
import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.Disposer
import com.intellij.testFramework.SkipInHeadlessEnvironment
import com.intellij.util.containers.ContainerUtil
import org.jetbrains.plugins.gradle.testutil.ChangeBuilder
import org.picocontainer.defaults.DefaultPicoContainer
import org.jetbrains.plugins.gradle.diff.*
import static org.junit.Assert.assertEquals
-import com.intellij.openapi.util.Disposer
/**
* @author Denis Zhdanov
treeChecker = new ProjectStructureChecker()
container = new DefaultPicoContainer()
container.registerComponentInstance(Project, intellij.project)
- container.registerComponentInstance(GradleProjectStructureHelper, intellij.projectStructureHelper as GradleProjectStructureHelper)
+ container.registerComponentInstance(PlatformFacade, intellij.platformFacade as PlatformFacade)
container.registerComponentImplementation(GradleProjectStructureChangesModel)
container.registerComponentImplementation(GradleStructureChangesCalculator, GradleProjectStructureChangesCalculator)
container.registerComponentImplementation(GradleModuleStructureChangesCalculator)
container.registerComponentImplementation(GradleProjectStructureTreeModel)
changesModel = container.getComponentInstance(GradleProjectStructureChangesModel) as GradleProjectStructureChangesModel
- def applicationInfo = [getSmallIconUrl: {"/nodes/ideaProject.png"}] as ApplicationInfoEx
- ApplicationManager.setApplication([getComponent: { applicationInfo } ] as Application, disposable)
}
@After
} } } }
}
+ @SuppressWarnings("GroovyAssignabilityCheck")
private def init(gradleProjectInit, intellijProjectInit) {
treeModel = container.getComponentInstance(GradleProjectStructureTreeModel) as GradleProjectStructureTreeModel
changesModel.addListener({ old, current ->
import com.intellij.pom.java.LanguageLevel
import com.intellij.openapi.module.Module
-import com.intellij.openapi.roots.RootPolicy
+
import com.intellij.openapi.roots.libraries.Library
import com.intellij.openapi.roots.LibraryOrderEntry
-import groovy.mock.interceptor.StubFor
+
import com.intellij.openapi.project.Project
+import com.intellij.openapi.util.IconLoader
/**
* @author Denis Zhdanov
def projectStub = [:]
def project = projectStub as Project
- def projectStructureHelper = [
+ def platformFacade = [
getModules: { modules },
- getOrderEntries: { dependencies[it] }
+ getOrderEntries: { dependencies[it] },
+ getProjectIcon: { IconLoader.getIcon("/nodes/ideaProject.png") }
]
@Override
protected createProject(String name, LanguageLevel languageLevel) {
projectStub.getName = { name }
- projectStructureHelper.getLanguageLevel = { languageLevel }
+ platformFacade.getLanguageLevel = { languageLevel }
project
}