From e1ac2000de46fad83b39edc6a0d16103df4f8889 Mon Sep 17 00:00:00 2001 From: Doug Schaefer Date: Sat, 30 May 2015 22:55:41 -0400 Subject: [PATCH] Final LaunchBar 1.0 API. Lots of clean up and simplification. launchConfigAdded becomes pretty important. Requires providers to be able to find descriptor and target from the incoming configuration if they own it. Also added handing for a default when the target is null. removed ownsConfiguration in providers since the launchConfigAdd does that by returning false. Added enablement for config providers, but that will need work and some default property testers for it to be useful. For the correct way to add in a config provider, check out the Arduino change for this API at: https://git.eclipse.org/r/#/c/49029/ Change-Id: I46b194a933c846d7d3e4eea8a0213c4ec324816f --- bundles/org.eclipse.launchbar.core/plugin.xml | 5 +- .../schema/launchBarContributions.exsd | 5 +- .../core/AbstractLaunchConfigProvider.java | 23 +- .../core/DefaultLaunchConfigProvider.java | 36 +-- .../launchbar/core/ILaunchBarManager.java | 22 +- .../core/ILaunchConfigurationProvider.java | 72 +++-- .../launchbar/core/ILaunchDescriptor.java | 10 +- .../launchbar/core/ILaunchDescriptorType.java | 27 +- .../core/PerTargetLaunchConfigProvider.java | 235 +++++++---------- .../core/ProjectLaunchDescriptor.java | 36 ++- .../ProjectPerTargetLaunchConfigProvider.java | 48 ++-- .../internal/DefaultLaunchDescriptorType.java | 21 +- .../core/internal/LaunchBarManager.java | 245 ++++++++++-------- .../internal/LaunchConfigProviderInfo.java | 35 +++ .../internal/LaunchDescriptorTypeInfo.java | 10 +- .../internal/ProjectLaunchObjectProvider.java | 11 +- .../PerTargetLaunchConfigProviderTest.java | 78 ++++-- .../core/internal/LaunchBarManager2Test.java | 143 +++++----- .../core/internal/LaunchBarManagerTest.java | 40 +-- 19 files changed, 596 insertions(+), 506 deletions(-) diff --git a/bundles/org.eclipse.launchbar.core/plugin.xml b/bundles/org.eclipse.launchbar.core/plugin.xml index 47331771ed4..a34277ac63a 100644 --- a/bundles/org.eclipse.launchbar.core/plugin.xml +++ b/bundles/org.eclipse.launchbar.core/plugin.xml @@ -12,7 +12,10 @@ class="org.eclipse.launchbar.core.internal.DefaultLaunchDescriptorType" id="org.eclipse.launchbar.core.descriptorType.default" priority="0"> - + + + - + @@ -98,6 +98,9 @@ descriptor with priority 5. Priority 0 is reserved for default descriptor. + + + diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/AbstractLaunchConfigProvider.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/AbstractLaunchConfigProvider.java index dbddba5fc16..9ddd7c46de4 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/AbstractLaunchConfigProvider.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/AbstractLaunchConfigProvider.java @@ -3,30 +3,33 @@ package org.eclipse.launchbar.core; import org.eclipse.core.runtime.CoreException; import org.eclipse.debug.core.DebugPlugin; import org.eclipse.debug.core.ILaunchConfiguration; +import org.eclipse.debug.core.ILaunchConfigurationType; import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; import org.eclipse.debug.core.ILaunchManager; import org.eclipse.launchbar.core.internal.Activator; import org.eclipse.remote.core.IRemoteConnection; /** - * Common launch config provider. Manages creating launch configurations and ensuring - * duplicates are managed properly. + * Common launch config provider. Manages creating launch configurations and + * ensuring duplicates are managed properly. */ public abstract class AbstractLaunchConfigProvider implements ILaunchConfigurationProvider { private static final String ATTR_ORIGINAL_NAME = Activator.PLUGIN_ID + ".originalName"; //$NON-NLS-1$ private static final String ATTR_PROVIDER_CLASS = Activator.PLUGIN_ID + ".providerClass"; //$NON-NLS-1$ - protected ILaunchConfiguration createLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException { + protected ILaunchConfiguration createLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target) + throws CoreException { ILaunchManager launchManager = DebugPlugin.getDefault().getLaunchManager(); String name = launchManager.generateLaunchConfigurationName(descriptor.getName()); - ILaunchConfigurationWorkingCopy workingCopy = getLaunchConfigurationType(descriptor, target).newInstance(null, name); + ILaunchConfigurationType type = getLaunchConfigurationType(descriptor, target); + ILaunchConfigurationWorkingCopy workingCopy = type.newInstance(null, name); populateLaunchConfiguration(descriptor, target, workingCopy); return workingCopy.doSave(); } - + protected void populateLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target, ILaunchConfigurationWorkingCopy workingCopy) throws CoreException { // Leave our breadcrumb @@ -34,14 +37,18 @@ public abstract class AbstractLaunchConfigProvider implements ILaunchConfigurati workingCopy.setAttribute(ATTR_PROVIDER_CLASS, getClass().getName()); } - @Override - public boolean ownsLaunchConfiguration(ILaunchConfiguration configuration) throws CoreException { + protected boolean ownsLaunchConfiguration(ILaunchConfiguration configuration) throws CoreException { + if (!configuration.exists()) { + // can't own it if it doesn't exist + return false; + } + // Check for our class name but also that the config name // matches what we originally set it to. // This covers the case when the config was duplicated. // We can own only one, the original one. return configuration.getAttribute(ATTR_PROVIDER_CLASS, "").equals(getClass().getName()) //$NON-NLS-1$ - && configuration.getAttribute(ATTR_ORIGINAL_NAME, "").equals(configuration.getName()); //$NON-NLS-1$ + && configuration.getAttribute(ATTR_ORIGINAL_NAME, "").equals(configuration.getName()); //$NON-NLS-1$ } } diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/DefaultLaunchConfigProvider.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/DefaultLaunchConfigProvider.java index 36ae2dbd50c..87a70b31c87 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/DefaultLaunchConfigProvider.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/DefaultLaunchConfigProvider.java @@ -6,15 +6,14 @@ import org.eclipse.debug.core.ILaunchConfigurationType; import org.eclipse.remote.core.IRemoteConnection; /** - * The launch config provider for the default descriptor which is the launch config itself. + * The launch config provider for the default descriptor which is the launch + * config itself. * - * Override this class and register an extension if you want to support targets other than the local connection. + * Override this class and register an extension if you want to support targets + * other than the local connection. */ public class DefaultLaunchConfigProvider implements ILaunchConfigurationProvider { - /** - * Only support local connection. Override to support different types of connection. - */ @Override public boolean supports(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException { // Only supports Local connection @@ -37,20 +36,20 @@ public class DefaultLaunchConfigProvider implements ILaunchConfigurationProvider return descriptor.getAdapter(ILaunchConfiguration.class); } - /** - * If you do override this method and return true you would have to make sure you add launch object which matches - * this configuration, otherwise it will not be visible - */ @Override - public boolean ownsLaunchConfiguration(ILaunchConfiguration configuration) throws CoreException { - // return false so that the config is added as a launch object + public boolean launchConfigurationAdded(ILaunchConfiguration configuration) throws CoreException { + // return false so that the configuration can become a launch object + return false; + } + + @Override + public boolean launchConfigurationChanged(ILaunchConfiguration configuration) throws CoreException { return false; } @Override public boolean launchConfigurationRemoved(ILaunchConfiguration configuration) throws CoreException { - // by contract we return true if we own or use to own configuration - return ownsLaunchConfiguration(configuration); + return false; } @Override @@ -63,15 +62,4 @@ public class DefaultLaunchConfigProvider implements ILaunchConfigurationProvider // nothing to do } - @Override - public boolean launchConfigurationAdded(ILaunchConfiguration configuration) throws CoreException { - // by contract we return true if we own configuration - return ownsLaunchConfiguration(configuration); - } - - @Override - public boolean launchConfigurationChanged(ILaunchConfiguration configuration) throws CoreException { - // by contract we return true if we own configuration - return ownsLaunchConfiguration(configuration); - } } diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchBarManager.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchBarManager.java index e81a0a5ea43..9f6f4387d35 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchBarManager.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchBarManager.java @@ -11,22 +11,32 @@ package org.eclipse.launchbar.core; import org.eclipse.core.runtime.CoreException; +import org.eclipse.debug.core.ILaunchConfigurationListener; -public interface ILaunchBarManager { +/** + * Interface to the Launch Bar Manager. + * + * @noimplement This interface is not intended to be implemented by clients. + */ +public interface ILaunchBarManager extends ILaunchConfigurationListener { /** - * A launch object has been added. Create a matching launch descriptor if available. + * A launch object has been added. Create a matching launch descriptor if + * available. * - * @param element launch object + * @param element + * launch object * @return the launch descriptor that got created, null of none was * @throws CoreException */ ILaunchDescriptor launchObjectAdded(Object launchObject) throws CoreException; /** - * A launch object has been removed. Remove the associated launch descriptor if there is one. + * A launch object has been removed. Remove the associated launch descriptor + * if there is one. * - * @param element launch object + * @param element + * launch object * @throws CoreException */ void launchObjectRemoved(Object launchObject) throws CoreException; @@ -39,6 +49,4 @@ public interface ILaunchBarManager { */ void launchObjectChanged(Object launchObject) throws CoreException; - // TODO API for adding and removing types. - } diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchConfigurationProvider.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchConfigurationProvider.java index 91520233b45..b416f87ea40 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchConfigurationProvider.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchConfigurationProvider.java @@ -16,23 +16,23 @@ import org.eclipse.debug.core.ILaunchConfigurationType; import org.eclipse.remote.core.IRemoteConnection; /** - * The provider of launch configurations of a given type for a given descriptor type - * and a given target type. + * The provider of launch configurations of a given type for a given descriptor + * type and a given target type. * - * It is recommended to extend {@link AbstractLaunchConfigProvider} or one of it's - * subclasses instead of implementing this directly. + * It is recommended to extend {@link AbstractLaunchConfigProvider} or one of + * it's subclasses instead of implementing this directly. */ public interface ILaunchConfigurationProvider { /** - * Does this config provider provide launch configurations for the combination - * of descriptor and target. + * Does this config provider provide launch configurations for the + * combination of descriptor and target. * * Note: this is called when filtering targets for a descriptor. Processing * should be minimal. * * @param descriptor * @param target - * @return true if target is supported, false otherwise. + * @return true if target is supported, false otherwise. */ boolean supports(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException; @@ -40,39 +40,42 @@ public interface ILaunchConfigurationProvider { * Return the launch configuation type for the descriptor and target. * * @param descriptor - * @param target launch configuration type or null if not supported + * @param target + * launch configuration type or null if not supported * @return * @throws CoreException */ - ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor, - IRemoteConnection target) throws CoreException; + ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor, IRemoteConnection target) + throws CoreException; /** * Create a launch configuration for the descriptor to launch on the target. * - * @param descriptor the descriptor to create the config for - * @param target the target to launch the config on + * @param descriptor + * the descriptor to create the config for + * @param target + * the target to launch the config on * @return launch configuration - * @throws CoreException + * @throws CoreException */ ILaunchConfiguration getLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException; /** - * Does this provider own the launch configuration. + * A launch configuration has been added. Provider can inspect it and + * associate with internal map. Provider should make sure it owns this + * launch configuration or it can modify it to take over. * - * @param configuration launch configuration - * @return true if this provider owns the launch configuration - * @throws CoreException + * @return true of provider owns this launch configuration */ - boolean ownsLaunchConfiguration(ILaunchConfiguration configuration) throws CoreException; + boolean launchConfigurationAdded(ILaunchConfiguration configuration) throws CoreException; /** - * A launch configuration has been removed. - * This notification can be used to purge internal cache for example. - * This method is called after launch configuration has been removed from file system, - * so accessing its attributes won't work. - * If provider cannot determine if it owns it it should return false. + * A launch configuration has been removed. This notification can be used to + * purge internal cache for example. This method is called after launch + * configuration has been removed from file system, so accessing its + * attributes won't work. If provider cannot determine if it owns it it + * should return false. * * @param configuration * @return true if provider owns this launch configuration @@ -81,23 +84,17 @@ public interface ILaunchConfigurationProvider { boolean launchConfigurationRemoved(ILaunchConfiguration configuration) throws CoreException; /** - * A launch configuration has been added. Provider can inspect it and associate with internal map. - * Provider should make sure it owns this launch configuration or it can modify it to take over. - * - * @return true of provider owns this launch configuration - */ - boolean launchConfigurationAdded(ILaunchConfiguration configuration) throws CoreException; - - /** - * A launch configuration has been changed. Provider can inspect it to re-evaluate its internal map. - * Provider should make sure it owns this launch configuration or it can modify it to take over. + * A launch configuration has been changed. Provider can inspect it to + * re-evaluate its internal map. Provider should make sure it owns this + * launch configuration or it can modify it to take over. * * @return true of provider owns this launch configuration */ boolean launchConfigurationChanged(ILaunchConfiguration configuration) throws CoreException; + /** - * A launch descriptor has been removed. Remove any launch configurations that were - * created for it. + * A launch descriptor has been removed. Remove any launch configurations + * that were created for it. * * @param descriptor * @throws CoreException @@ -105,13 +102,12 @@ public interface ILaunchConfigurationProvider { void launchDescriptorRemoved(ILaunchDescriptor descriptor) throws CoreException; /** - * A launch target has been removed. Remove any launch configurations that were created - * for it. + * A launch target has been removed. Remove any launch configurations that + * were created for it. * * @param target * @throws CoreException */ void launchTargetRemoved(IRemoteConnection target) throws CoreException; - } diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchDescriptor.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchDescriptor.java index de457386e68..f0806988d50 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchDescriptor.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchDescriptor.java @@ -12,17 +12,15 @@ package org.eclipse.launchbar.core; import org.eclipse.core.runtime.IAdaptable; - /** - * Represents a thing that can be launched. - * It is good practice that the descriptor is adaptable to the launch object - * it is representing. + * Represents a thing that can be launched. It is good practice that the + * descriptor is adaptable to the launch object it is representing. */ public interface ILaunchDescriptor extends IAdaptable { /** - * Name to show in the launch descriptor selector. - * Names must be unique for all descriptors of a given type. + * Name to show in the launch descriptor selector. Names must be unique for + * all descriptors of a given type. * * @return name of the launch descriptor */ diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchDescriptorType.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchDescriptorType.java index 49edd67687d..6452c7d2efe 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchDescriptorType.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ILaunchDescriptorType.java @@ -14,33 +14,22 @@ import org.eclipse.core.runtime.CoreException; /** * Provides mapping between launch objects and launch descriptors. - * - * It is strongly recommended to extend AbstarctLaunchDescriptorType instead of implementing this directly */ public interface ILaunchDescriptorType { - /** - * Does this type own this launch object? - * - * The main checking should be done in enablement expression of extension declaring the type, - * if enablement expression if defined this method can return true. - * This also can used for fine-tuning of ownership - * which is hard to declared in xml. - * - * @param element - * @return owns element - * @throws CoreException - */ - boolean ownsLaunchObject(Object launchObject) throws CoreException; /** * Return a descriptor for the given launch object. * - * May return null to essentially eat the element so no other types - * create a descriptor for it. + * May return null to essentially eat the element so no other types create a + * descriptor for it. * - * @param descriptor launch object for descriptor + * The enablement expression for a given launch object must pass for this + * clause to be executed. + * + * @param descriptor + * launch object for descriptor * @return the best descriptor - * @throws CoreException + * @throws CoreException */ ILaunchDescriptor getDescriptor(Object launchObject) throws CoreException; diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/PerTargetLaunchConfigProvider.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/PerTargetLaunchConfigProvider.java index 8652d880a66..fbefcb6fb9d 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/PerTargetLaunchConfigProvider.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/PerTargetLaunchConfigProvider.java @@ -9,201 +9,146 @@ import java.util.Map.Entry; import org.eclipse.core.runtime.CoreException; import org.eclipse.debug.core.ILaunchConfiguration; -import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; import org.eclipse.launchbar.core.internal.Activator; import org.eclipse.remote.core.IRemoteConnection; -import org.eclipse.remote.core.IRemoteConnectionType; -import org.eclipse.remote.core.IRemoteServicesManager; public abstract class PerTargetLaunchConfigProvider extends AbstractLaunchConfigProvider { - public final String ATTR_CONNECTION_TYPE = getConnectionTypeAttribute(); - public final String ATTR_CONNECTION_NAME = getConnectionNameAttribute(); - private final Map> configMap = new HashMap<>(); + private final Map defaultConfigs = new HashMap<>(); private final Collection ownedConfigs = new LinkedHashSet<>(); - protected String getConnectionNameAttribute() { - return "org.eclipse.launchbar.core.connectionName";//$NON-NLS-1$ - } - - protected String getConnectionTypeAttribute() { - return "org.eclipse.launchbar.core.connectionType";//$NON-NLS-1$ + protected ILaunchBarManager getManager() { + return Activator.getService(ILaunchBarManager.class); } @Override public ILaunchConfiguration getLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException { - Map targetMap = getTargetMap(descriptor); - ILaunchConfiguration config = targetMap.get(target); - if (config != null) { - return config; - } - // first search for owned configurations, to see if any match to descriptor - config = findLaunchConfiguration(descriptor, target); - if (config == null) { - config = createLaunchConfiguration(descriptor, target); - launchConfigurationAdded(config); - } - targetMap.put(target, config); - return config; - } - - protected Map getTargetMap(ILaunchDescriptor descriptor) { - Map targetMap = configMap.get(descriptor); - if (targetMap == null) { - targetMap = new HashMap<>(); - configMap.put(descriptor, targetMap); - } - return targetMap; - } - - protected ILaunchConfiguration findLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target) - throws CoreException { - for (ILaunchConfiguration configuration : ownedConfigs) { - if (descriptorAndTargetMatchesConfiguration(descriptor, target, configuration)) { - return configuration; + if (target != null) { + Map targetMap = configMap.get(descriptor); + if (targetMap != null) { + ILaunchConfiguration config = targetMap.get(target); + if (config != null) { + return config; + } + } + } else { + ILaunchConfiguration config = defaultConfigs.get(descriptor); + if (config != null) { + return config; } } - return null; + + // The config will get added to the cache when launchConfigurationAdded + // is called when the new config is saved. + return createLaunchConfiguration(descriptor, target); } - protected boolean descriptorAndTargetMatchesConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target, - ILaunchConfiguration configuration) { - if (targetMatchesConfiguration(target, configuration) == false) - return false; - if (descriptorMatchesConfiguration(descriptor, configuration) == false) + protected abstract ILaunchDescriptor getLaunchDescriptor(ILaunchConfiguration configuration) throws CoreException; + + protected abstract IRemoteConnection getLaunchTarget(ILaunchConfiguration configuration) throws CoreException; + + protected boolean providesForNullTarget() { + return false; + } + + private boolean addLaunchConfiguration(ILaunchConfiguration configuration) throws CoreException { + ILaunchDescriptor desc = getLaunchDescriptor(configuration); + if (desc == null) { return false; + } + + IRemoteConnection target = getLaunchTarget(configuration); + if (target == null) { + if (providesForNullTarget()) { + defaultConfigs.put(desc, configuration); + } else { + return false; + } + } else { + Map targetMap = configMap.get(desc); + if (targetMap == null) { + targetMap = new HashMap<>(); + configMap.put(desc, targetMap); + } + targetMap.put(target, configuration); + } + + ownedConfigs.add(configuration); return true; } - /** - * This method should be overridden to check that configuration does actually represent the descriptor. - * You don't need to check ownership since this method will be only called on owned configurations - */ - protected boolean descriptorMatchesConfiguration(ILaunchDescriptor descriptor, ILaunchConfiguration configuration) { - // we using startsWith instead of equals because new configuration using "generateLaunchConfigurationName" method which - // means only prefix guaranteed to be matching, and the prefix is the descriptor name - return configuration.getName().startsWith(descriptor.getName()); + @Override + public boolean launchConfigurationAdded(ILaunchConfiguration configuration) throws CoreException { + if (ownsLaunchConfiguration(configuration)) { + return addLaunchConfiguration(configuration); + } + return false; } - protected boolean targetMatchesConfiguration(IRemoteConnection target, ILaunchConfiguration configuration) { - String targetName; - try { - targetName = configuration.getAttribute(ATTR_CONNECTION_NAME, ""); - } catch (CoreException e) { - return false; - } - if (target != null && target.getName().equals(targetName)) { - return true; - } else if (target == null && (targetName == null || targetName.isEmpty())) { + @Override + public boolean launchConfigurationChanged(ILaunchConfiguration configuration) throws CoreException { + if (ownsLaunchConfiguration(configuration)) { + // clear cache, target could have changed + launchConfigurationRemoved(configuration); + return addLaunchConfiguration(configuration); + } else if (ownedConfigs.contains(configuration)) { + // something changed that will cause us to loose ownership of this + // configuration. Remove and add it back in. + ILaunchBarManager manager = getManager(); + manager.launchConfigurationRemoved(configuration); + manager.launchConfigurationAdded(configuration); return true; } else { return false; } } - @Override - protected void populateLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target, - ILaunchConfigurationWorkingCopy workingCopy) throws CoreException { - super.populateLaunchConfiguration(descriptor, target, workingCopy); - workingCopy.setAttribute(ATTR_CONNECTION_TYPE, target.getConnectionType().getId()); - workingCopy.setAttribute(ATTR_CONNECTION_NAME, target.getName()); - } - - public IRemoteConnection getTarget(ILaunchConfiguration configuration) throws CoreException { - IRemoteServicesManager remoteManager = Activator.getService(IRemoteServicesManager.class); - String connectionTypeId = configuration.getAttribute(ATTR_CONNECTION_TYPE, ""); //$NON-NLS-1$ - if (connectionTypeId.isEmpty()) { - return null; - } - IRemoteConnectionType connectionType = remoteManager.getConnectionType(connectionTypeId); - if (connectionType == null) { - return null; - } - String connectionName = configuration.getAttribute(ATTR_CONNECTION_NAME, ""); //$NON-NLS-1$ - if (connectionName.isEmpty()) { - return null; - } - return connectionType.getConnection(connectionName); - } - - @Override - public boolean ownsLaunchConfiguration(ILaunchConfiguration configuration) throws CoreException { - return ownedConfigs.contains(configuration); - } - - public boolean ownsLaunchConfigurationByAttributes(ILaunchConfiguration configuration) { - try { - return super.ownsLaunchConfiguration(configuration); - } catch (CoreException e) { - // will happened if called after LC is deleted - return false; - } - } - @Override public boolean launchConfigurationRemoved(ILaunchConfiguration configuration) throws CoreException { - boolean owned = ownsLaunchConfiguration(configuration); - if (owned) { - ownedConfigs.remove(configuration); - for (Entry> descEntry : configMap.entrySet()) { - for (Entry targetEntry : descEntry.getValue().entrySet()) { - if (targetEntry.getValue().equals(configuration)) { - descEntry.getValue().remove(targetEntry.getKey()); - if (descEntry.getValue().isEmpty()) { - configMap.remove(descEntry.getKey()); - } - return true; + ownedConfigs.remove(configuration); + for (Entry> descEntry : configMap.entrySet()) { + for (Entry targetEntry : descEntry.getValue().entrySet()) { + if (targetEntry.getValue().equals(configuration)) { + descEntry.getValue().remove(targetEntry.getKey()); + if (descEntry.getValue().isEmpty()) { + configMap.remove(descEntry.getKey()); } + return true; } } } - return owned; - } - - @Override - public boolean launchConfigurationAdded(ILaunchConfiguration configuration) throws CoreException { - if (ownsLaunchConfigurationByAttributes(configuration)) { - ownedConfigs.add(configuration); - return true; - } - return false; - } - - @Override - public boolean launchConfigurationChanged(ILaunchConfiguration configuration) throws CoreException { - if (ownsLaunchConfigurationByAttributes(configuration)) { - // clear cache, target could have changed - launchConfigurationRemoved(configuration); - ownedConfigs.add(configuration); - return true; - } else if (ownedConfigs.contains(configuration)) { - // user did something that will cause us to loose ownership of this configuration - launchConfigurationRemoved(configuration); - } return false; } @Override public void launchDescriptorRemoved(ILaunchDescriptor descriptor) throws CoreException { Map map = configMap.remove(descriptor); - if (map == null) - return; - for (ILaunchConfiguration config : map.values()) { + if (map != null) { + for (ILaunchConfiguration config : map.values()) { + ownedConfigs.remove(config); + // remove all auto-configs associated with descriptor + config.delete(); + } + } + + ILaunchConfiguration config = defaultConfigs.remove(descriptor); + if (config != null) { ownedConfigs.remove(config); - config.delete(); // remove all auto-configs associated with descriptor + config.delete(); } } @Override public void launchTargetRemoved(IRemoteConnection target) throws CoreException { - for (Iterator>> iterator = configMap.entrySet() - .iterator(); iterator.hasNext();) { + for (Iterator>> iterator = configMap + .entrySet().iterator(); iterator.hasNext();) { Entry> descEntry = iterator.next(); Map map = descEntry.getValue(); ILaunchConfiguration config = map.remove(target); if (config != null) { - config.delete(); // remove all auto-configs associated with target + // remove all auto-configs associated with target + config.delete(); } if (map.isEmpty()) { iterator.remove(); diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ProjectLaunchDescriptor.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ProjectLaunchDescriptor.java index 4796f9d0b61..bf4a2c63908 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ProjectLaunchDescriptor.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ProjectLaunchDescriptor.java @@ -14,8 +14,8 @@ import org.eclipse.core.resources.IProject; import org.eclipse.core.runtime.PlatformObject; /** - * A reusable descriptor for wrapping projects that can be used by descriptor types - * that map to projects. + * A reusable descriptor for wrapping projects that can be used by descriptor + * types that map to projects. */ public class ProjectLaunchDescriptor extends PlatformObject implements ILaunchDescriptor { @@ -49,4 +49,36 @@ public class ProjectLaunchDescriptor extends PlatformObject implements ILaunchDe public String toString() { return getName(); // for debugging purposes } + + @Override + public int hashCode() { + final int prime = 31; + int result = 1; + result = prime * result + ((project == null) ? 0 : project.hashCode()); + result = prime * result + ((type == null) ? 0 : type.hashCode()); + return result; + } + + @Override + public boolean equals(Object obj) { + if (this == obj) + return true; + if (obj == null) + return false; + if (getClass() != obj.getClass()) + return false; + ProjectLaunchDescriptor other = (ProjectLaunchDescriptor) obj; + if (project == null) { + if (other.project != null) + return false; + } else if (!project.equals(other.project)) + return false; + if (type == null) { + if (other.type != null) + return false; + } else if (!type.equals(other.type)) + return false; + return true; + } + } diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ProjectPerTargetLaunchConfigProvider.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ProjectPerTargetLaunchConfigProvider.java index fbde803bf02..7eb5116a960 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ProjectPerTargetLaunchConfigProvider.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/ProjectPerTargetLaunchConfigProvider.java @@ -15,42 +15,21 @@ import org.eclipse.core.resources.IResource; import org.eclipse.core.runtime.CoreException; import org.eclipse.debug.core.ILaunchConfiguration; import org.eclipse.debug.core.ILaunchConfigurationWorkingCopy; +import org.eclipse.launchbar.core.internal.Activator; import org.eclipse.remote.core.IRemoteConnection; public abstract class ProjectPerTargetLaunchConfigProvider extends PerTargetLaunchConfigProvider { + @Override public boolean supports(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException { return (descriptor.getAdapter(IProject.class) != null); } - @Override - protected boolean descriptorMatchesConfiguration(ILaunchDescriptor descriptor, ILaunchConfiguration configuration) { - IProject project = descriptor.getAdapter(IProject.class); - if (project == null || configuration == null) - return false; - return (project.equals(getProject(configuration))); - } - - protected IProject getProject(ILaunchConfiguration configuration) { - IResource[] mappedResources = null; - try { - mappedResources = configuration.getMappedResources(); - } catch (CoreException e) { - return null; - } - if (mappedResources == null) - return null; - for (IResource resource : mappedResources) { - if (resource instanceof IProject) - return (IProject) resource; - } - return null; - } - @Override protected void populateLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target, ILaunchConfigurationWorkingCopy workingCopy) throws CoreException { super.populateLaunchConfiguration(descriptor, target, workingCopy); + // Add our project to the mapped resources IProject project = descriptor.getAdapter(IProject.class); IResource[] mappedResources = workingCopy.getMappedResources(); @@ -63,4 +42,25 @@ public abstract class ProjectPerTargetLaunchConfigProvider extends PerTargetLaun workingCopy.setMappedResources(newResources); } } + + @Override + protected ILaunchDescriptor getLaunchDescriptor(ILaunchConfiguration configuration) throws CoreException { + IResource[] mappedResources = configuration.getMappedResources(); + if (mappedResources == null) { + return null; + } + + IProject project = null; + for (IResource resource : mappedResources) { + if (resource instanceof IProject) + project = (IProject) resource; + } + if (project == null) { + return null; + } + + ILaunchBarManager manager = Activator.getService(ILaunchBarManager.class); + return manager.launchObjectAdded(project); + } + } diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/DefaultLaunchDescriptorType.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/DefaultLaunchDescriptorType.java index 350d04ae27a..ecacc4b51a4 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/DefaultLaunchDescriptorType.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/DefaultLaunchDescriptorType.java @@ -10,8 +10,8 @@ import org.eclipse.launchbar.core.ILaunchDescriptor; import org.eclipse.launchbar.core.ILaunchDescriptorType; /** - * A special descriptor type that managed configurations that aren't owned - * by other descriptor types. + * A special descriptor type that managed configurations that aren't owned by + * other descriptor types. */ public class DefaultLaunchDescriptorType implements ILaunchDescriptorType { @@ -20,16 +20,11 @@ public class DefaultLaunchDescriptorType implements ILaunchDescriptorType { private Map descriptors = new HashMap<>(); @Override - public boolean ownsLaunchObject(Object element) { - return element instanceof ILaunchConfiguration; - } - - @Override - public ILaunchDescriptor getDescriptor(Object element) { - if (element instanceof ILaunchConfiguration) { - ILaunchConfiguration config = (ILaunchConfiguration) element; + public ILaunchDescriptor getDescriptor(Object launchObject) { + if (launchObject instanceof ILaunchConfiguration) { + ILaunchConfiguration config = (ILaunchConfiguration) launchObject; try { - if( config.getType() != null && config.getType().isPublic() + if (config.getType() != null && config.getType().isPublic() && !(config.getAttribute(ILaunchManager.ATTR_PRIVATE, false))) { DefaultLaunchDescriptor descriptor = descriptors.get(config); @@ -39,9 +34,9 @@ public class DefaultLaunchDescriptorType implements ILaunchDescriptorType { } return descriptor; } - } catch(CoreException ce) { + } catch (CoreException ce) { Activator.log(ce.getStatus()); - } + } } return null; diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchBarManager.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchBarManager.java index 79c876f5f92..998a8722d32 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchBarManager.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchBarManager.java @@ -32,7 +32,6 @@ import org.eclipse.core.runtime.preferences.IEclipsePreferences; import org.eclipse.core.runtime.preferences.InstanceScope; import org.eclipse.debug.core.DebugPlugin; import org.eclipse.debug.core.ILaunchConfiguration; -import org.eclipse.debug.core.ILaunchConfigurationListener; import org.eclipse.debug.core.ILaunchConfigurationType; import org.eclipse.debug.core.ILaunchManager; import org.eclipse.debug.core.ILaunchMode; @@ -52,14 +51,19 @@ import org.osgi.service.prefs.Preferences; /** * The brains of the launch bar. */ -public class LaunchBarManager implements ILaunchBarManager, ILaunchConfigurationListener, IRemoteConnectionChangeListener { +public class LaunchBarManager implements ILaunchBarManager, IRemoteConnectionChangeListener { - // TODO make these more fine grained or break them into more focused listeners + // TODO make these more fine grained or break them into more focused + // listeners public interface Listener { void activeLaunchDescriptorChanged(); + void activeLaunchModeChanged(); + void activeLaunchTargetChanged(); + void launchDescriptorRemoved(ILaunchDescriptor descriptor); + void launchTargetsChanged(); } @@ -90,7 +94,7 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration private ILaunchMode activeLaunchMode; private IRemoteConnection activeLaunchTarget; - // private static final String PREF_ACTIVE_CONFIG_DESC = "activeConfigDesc"; + // private static final String PREF_ACTIVE_CONFIG_DESC = "activeConfigDesc"; private static final String PREF_ACTIVE_LAUNCH_MODE = "activeLaunchMode"; //$NON-NLS-1$ private static final String PREF_ACTIVE_LAUNCH_TARGET = "activeLaunchTarget"; //$NON-NLS-1$ private static final String PREF_CONFIG_DESC_ORDER = "configDescList"; //$NON-NLS-1$ @@ -194,7 +198,6 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration descriptorTypes.put(typeInfo.getId(), typeInfo); - if (configProviders.get(typeInfo.getId()) == null) { // Make sure we initialize the list configProviders.put(typeInfo.getId(), new ArrayList()); @@ -249,18 +252,21 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration } - // Now that all the types are loaded, the object providers which now populate the descriptors + // Now that all the types are loaded, the object providers which now + // populate the descriptors for (IExtension extension : extensions) { for (IConfigurationElement element : extension.getConfigurationElements()) { try { String elementName = element.getName(); if (elementName.equals("objectProvider")) { //$NON-NLS-1$ - ILaunchObjectProvider objectProvider = (ILaunchObjectProvider) element.createExecutableExtension("class"); //$NON-NLS-1$ + ILaunchObjectProvider objectProvider = (ILaunchObjectProvider) element + .createExecutableExtension("class"); //$NON-NLS-1$ objectProviders.add(objectProvider); objectProvider.init(this); } } catch (Exception e) { - Activator.log(e); // exceptions during extension loading, log and move on + // exceptions during extension loading, log and move on + Activator.log(e); } } } @@ -297,48 +303,21 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration setActiveLaunchDescriptor(descriptor); } - private void removeDescriptor(Object launchObject, ILaunchDescriptor descriptor) throws CoreException { - objectDescriptorMap.remove(launchObject); // remove launch object unconditionally - if (descriptor != null) { - descriptors.remove(getDescriptorId(descriptor)); - if (descriptor.equals(activeLaunchDesc)) { - setActiveLaunchDescriptor(getLastUsedDescriptor()); - } - - for (LaunchConfigProviderInfo provider : configProviders.get(getDescriptorTypeId(descriptor.getType()))) { - provider.getProvider().launchDescriptorRemoved(descriptor); - } - } - } - - public ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException { + public ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor, IRemoteConnection target) + throws CoreException { if (descriptor == null) return null; - for (LaunchConfigProviderInfo provider : configProviders.get(getDescriptorTypeId(descriptor.getType()))) { - ILaunchConfigurationType type = provider.getProvider().getLaunchConfigurationType(descriptor, target); - if (type != null) { - return type; - } - } - - return null; - } - - private ILaunchDescriptorType ownsLaunchObject(Object launchObject) throws CoreException { - for (LaunchDescriptorTypeInfo descriptorInfo : orderedDescriptorTypes) { - try { - if (descriptorInfo.ownsLaunchObject(launchObject)) { - ILaunchDescriptorType type = descriptorInfo.getType(); - descriptorTypeInfo.put(type, descriptorInfo); - if (type.ownsLaunchObject(launchObject)) { - return type; - } + for (LaunchConfigProviderInfo providerInfo : configProviders.get(getDescriptorTypeId(descriptor.getType()))) { + if (providerInfo.enabled(descriptor) && providerInfo.enabled(target)) { + ILaunchConfigurationType type = providerInfo.getProvider().getLaunchConfigurationType(descriptor, + target); + if (type != null) { + return type; } - } catch (Throwable e) { - Activator.log(e); // one of used defined launch types is misbehaving } } + return null; } @@ -346,51 +325,77 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration public ILaunchDescriptor launchObjectAdded(Object launchObject) { Activator.trace("launch object added " + launchObject); //$NON-NLS-1$ ILaunchDescriptor desc = objectDescriptorMap.get(launchObject); - if (desc != null) + if (desc != null) { return desc; - - try { - ILaunchDescriptorType type = ownsLaunchObject(launchObject); - if (type != null) { - desc = type.getDescriptor(launchObject); - if (desc != null) { - addDescriptor(launchObject, desc); - } - } - } catch (Throwable e) { - Activator.log(e); } - return desc; + for (LaunchDescriptorTypeInfo descriptorInfo : orderedDescriptorTypes) { + try { + if (descriptorInfo.enabled(launchObject)) { + ILaunchDescriptorType type = descriptorInfo.getType(); + // For newly loaded types, this is the first time we see + // them + // Add it to the info map. + descriptorTypeInfo.put(type, descriptorInfo); + desc = type.getDescriptor(launchObject); + if (desc != null) { + addDescriptor(launchObject, desc); + return desc; + } + + } + } catch (Throwable e) { + Activator.log(e); + } + } + + return null; } @Override public void launchObjectRemoved(Object launchObject) throws CoreException { Activator.trace("launch object removed " + launchObject); //$NON-NLS-1$ - ILaunchDescriptor desc = objectDescriptorMap.get(launchObject); - removeDescriptor(launchObject, desc); + ILaunchDescriptor descriptor = objectDescriptorMap.remove(launchObject); + if (descriptor != null) { + descriptors.remove(getDescriptorId(descriptor)); + if (descriptor.equals(activeLaunchDesc)) { + setActiveLaunchDescriptor(getLastUsedDescriptor()); + } + + for (LaunchConfigProviderInfo providerInfo : configProviders + .get(getDescriptorTypeId(descriptor.getType()))) { + if (providerInfo.enabled(descriptor)) { + providerInfo.getProvider().launchDescriptorRemoved(descriptor); + } + } + } } @Override public void launchObjectChanged(Object launchObject) throws CoreException { // TODO deal with object renames here, somehow - // check if a new descriptor wants to take over ILaunchDescriptor origDesc = objectDescriptorMap.get(launchObject); - ILaunchDescriptorType newDescType = ownsLaunchObject(launchObject); + if (origDesc == null) { + // See if anyone wants it now + launchObjectAdded(launchObject); + return; + } - if (newDescType != null) { - if (origDesc == null || !origDesc.getType().equals(newDescType)) { - // we have a take over - if (origDesc != null) { - removeDescriptor(launchObject, origDesc); - } - - ILaunchDescriptor newDesc = newDescType.getDescriptor(launchObject); - if (newDesc != null) { - addDescriptor(launchObject, newDesc); - } + // check if descriptor still wants it + ILaunchDescriptorType origDescType = origDesc.getType(); + try { + ILaunchDescriptor newDesc = origDescType.getDescriptor(launchObject); + if (newDesc == null) { + // nope, give it back to the pool + objectDescriptorMap.remove(launchObject); + launchObjectAdded(launchObject); + } else if (!newDesc.equals(origDesc)) { + // record the new descriptor + objectDescriptorMap.put(launchObject, newDesc); } + } catch (Throwable e) { + Activator.log(e); } } @@ -402,7 +407,8 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration } public ILaunchDescriptor[] getLaunchDescriptors() { - // return descriptor in usage order (most used first). UI can sort them later as it wishes + // return descriptor in usage order (most used first). UI can sort them + // later as it wishes ArrayList values = new ArrayList<>(descriptors.values()); Collections.reverse(values); return values.toArray(new ILaunchDescriptor[values.size()]); @@ -415,18 +421,23 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration public void setActiveLaunchDescriptor(ILaunchDescriptor descriptor) throws CoreException { Activator.trace("set active descriptor " + descriptor); //$NON-NLS-1$ if (activeLaunchDesc == descriptor) { - // Sync since targets could be changed since last time (and modes theoretically too) + // Sync since targets could be changed since last time (and modes + // theoretically too) syncActiveTarget(); syncActiveMode(); Activator.trace("resync for " + descriptor); //$NON-NLS-1$ return; } - if (descriptor != null && !descriptors.containsValue(descriptor)) + if (descriptor != null && !descriptors.containsValue(descriptor)) { throw new IllegalStateException(Messages.LaunchBarManager_1); - if (descriptor == null) - descriptor = getLastUsedDescriptor(); // do not set to null unless no descriptors + } + if (descriptor == null) { + // do not set to null unless no descriptors + descriptor = getLastUsedDescriptor(); + } activeLaunchDesc = descriptor; - if (descriptor != null) { // keeps most used descriptor last + if (descriptor != null) { + // keeps most used descriptor last Pair id = getDescriptorId(descriptor); descriptors.remove(id); descriptors.put(id, descriptor); @@ -447,7 +458,8 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration // Store the desc order, active one is the last one StringBuffer buff = new StringBuffer(); - for (Pair key : descriptors.keySet()) {// TODO: this can be very long string + // TODO: this can be very long string + for (Pair key : descriptors.keySet()) { if (buff.length() > 0) { buff.append(','); } @@ -485,17 +497,15 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration return; } ILaunchMode foundMode = null; - String storedModeId = getPerDescriptorStore().get(PREF_ACTIVE_LAUNCH_MODE, null); // last desc mode id + // last desc mode id + String storedModeId = getPerDescriptorStore().get(PREF_ACTIVE_LAUNCH_MODE, null); String lastActiveModeId = activeLaunchMode == null ? null : activeLaunchMode.getIdentifier(); - ILaunchMode[] supportedModes = getLaunchModes(); // this is based on active desc and target which are already set + // this is based on active desc and target which are already set + ILaunchMode[] supportedModes = getLaunchModes(); if (supportedModes.length > 0) { // mna, what if no modes are supported? - String modeNames[] = new String[] { - storedModeId, - lastActiveModeId, - "run", //$NON-NLS-1$ + String modeNames[] = new String[] { storedModeId, lastActiveModeId, "run", //$NON-NLS-1$ "debug", //$NON-NLS-1$ - supportedModes[0].getIdentifier() - }; + supportedModes[0].getIdentifier() }; for (int i = 0; i < modeNames.length; i++) { foundMode = getLaunchManager().getLaunchMode(modeNames[i]); if (supportsMode(foundMode)) @@ -554,7 +564,8 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration } private void fireActiveLaunchDescriptorChanged() { - if (!initialized) return; + if (!initialized) + return; for (Listener listener : listeners) { try { listener.activeLaunchDescriptorChanged(); @@ -612,7 +623,8 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration } private void fireActiveLaunchModeChanged() { - if (!initialized) return; + if (!initialized) + return; for (Listener listener : listeners) { try { listener.activeLaunchModeChanged(); @@ -622,7 +634,6 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration } } - private void storeLaunchMode(ILaunchDescriptor desc, ILaunchMode mode) { if (mode != null) { // per desc store, desc can null if will be stored globally @@ -646,10 +657,12 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration boolean supportsTarget(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException { String descriptorTypeId = getDescriptorTypeId(descriptor.getType()); - for (LaunchConfigProviderInfo provider : configProviders.get(descriptorTypeId)) { + for (LaunchConfigProviderInfo providerInfo : configProviders.get(descriptorTypeId)) { try { - if (provider.getProvider().supports(descriptor, target)) { - return true; + if (providerInfo.enabled(descriptor) && providerInfo.enabled(target)) { + if (providerInfo.getProvider().supports(descriptor, target)) { + return true; + } } } catch (Throwable e) { Activator.log(e); @@ -664,6 +677,7 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration /** * Sets preferred target for launch descriptor + * * @param desc * @param target * @throws CoreException @@ -682,19 +696,23 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration } activeLaunchTarget = target; storeLaunchTarget(activeLaunchDesc, target); + syncActiveMode(); fireActiveLaunchTargetChanged(); // notify listeners } private void storeLaunchTarget(ILaunchDescriptor desc, IRemoteConnection target) { if (target == null) { - return; // no point storing null, if stored id is invalid it won't be used anyway + // no point storing null, if stored id is invalid it won't be used + // anyway + return; } // per desc store, desc can be null means it store globally setPreference(getPerDescriptorStore(desc), PREF_ACTIVE_LAUNCH_TARGET, toString(getTargetId(target))); } private void fireActiveLaunchTargetChanged() { - if (!initialized) return; + if (!initialized) + return; for (Listener listener : listeners) { try { listener.activeLaunchTargetChanged(); @@ -713,7 +731,6 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration return getLaunchConfiguration(activeLaunchDesc, activeLaunchTarget); } - public ILaunchConfiguration getLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException { if (descriptor == null) { @@ -723,13 +740,15 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration String descTypeId = getDescriptorTypeId(descriptor.getType()); for (LaunchConfigProviderInfo providerInfo : configProviders.get(descTypeId)) { try { - ILaunchConfigurationProvider provider = providerInfo.getProvider(); - // between multiple provider who support this descriptor we need to find one - // that supports this target - if (provider.supports(descriptor, target)) { - ILaunchConfiguration config = provider.getLaunchConfiguration(descriptor, target); - if (config != null) { - return config; + if (providerInfo.enabled(descriptor) && providerInfo.enabled(target)) { + ILaunchConfigurationProvider provider = providerInfo.getProvider(); + // between multiple provider who support this descriptor we + // need to find one that supports this target + if (provider.supports(descriptor, target)) { + ILaunchConfiguration config = provider.getLaunchConfiguration(descriptor, target); + if (config != null) { + return config; + } } } } catch (Throwable e) { @@ -757,9 +776,10 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration for (LaunchDescriptorTypeInfo descTypeInfo : orderedDescriptorTypes) { for (LaunchConfigProviderInfo providerInfo : configProviders.get(descTypeInfo.getId())) { try { - providerInfo.getProvider().launchConfigurationAdded(configuration); - if (providerInfo.getProvider().ownsLaunchConfiguration(configuration)) { - return; + if (providerInfo.enabled(configuration)) { + if (providerInfo.getProvider().launchConfigurationAdded(configuration)) { + return; + } } } catch (Throwable e) { Activator.log(e); @@ -778,12 +798,13 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration Activator.log(e); } - // TODO do I need to do this if configs are launch objects? for (LaunchDescriptorTypeInfo descTypeInfo : orderedDescriptorTypes) { for (LaunchConfigProviderInfo providerInfo : configProviders.get(descTypeInfo.getId())) { try { - if (providerInfo.getProvider().launchConfigurationRemoved(configuration)) { - return; + if (providerInfo.enabled(configuration)) { + if (providerInfo.getProvider().launchConfigurationRemoved(configuration)) { + return; + } } } catch (Throwable e) { Activator.log(e); @@ -797,7 +818,11 @@ public class LaunchBarManager implements ILaunchBarManager, ILaunchConfiguration for (LaunchDescriptorTypeInfo descTypeInfo : orderedDescriptorTypes) { for (LaunchConfigProviderInfo providerInfo : configProviders.get(descTypeInfo.getId())) { try { - providerInfo.getProvider().launchConfigurationChanged(configuration); + if (providerInfo.enabled(configuration)) { + if (providerInfo.getProvider().launchConfigurationChanged(configuration)) { + return; + } + } } catch (Throwable e) { Activator.log(e); } diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchConfigProviderInfo.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchConfigProviderInfo.java index 75219c64e57..8e178db020f 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchConfigProviderInfo.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchConfigProviderInfo.java @@ -1,7 +1,12 @@ package org.eclipse.launchbar.core.internal; +import org.eclipse.core.expressions.EvaluationContext; +import org.eclipse.core.expressions.EvaluationResult; +import org.eclipse.core.expressions.Expression; +import org.eclipse.core.expressions.ExpressionConverter; import org.eclipse.core.runtime.CoreException; import org.eclipse.core.runtime.IConfigurationElement; +import org.eclipse.core.runtime.Status; import org.eclipse.launchbar.core.ILaunchConfigurationProvider; public class LaunchConfigProviderInfo { @@ -9,6 +14,7 @@ public class LaunchConfigProviderInfo { private final int priority; private IConfigurationElement element; private ILaunchConfigurationProvider provider; + private Expression expression; public LaunchConfigProviderInfo(IConfigurationElement element) { this.descriptorTypeId = element.getAttribute("descriptorType"); //$NON-NLS-1$ @@ -23,6 +29,27 @@ public class LaunchConfigProviderInfo { priority = priorityNum; this.element = element; + + IConfigurationElement[] enabledExpressions = element.getChildren("enablement");//$NON-NLS-1$ + if (enabledExpressions == null || enabledExpressions.length == 0) { + Activator.log(new Status(Status.WARNING, Activator.PLUGIN_ID, + "Enablement expression is missing for config provider for " + descriptorTypeId)); //$NON-NLS-1$ + } else if (enabledExpressions.length > 1) { + Activator.log(new Status(Status.WARNING, Activator.PLUGIN_ID, + "Multiple enablement expressions are detected for config provider for "//$NON-NLS-1$ + + descriptorTypeId)); + } else { + try { + expression = ExpressionConverter.getDefault().perform(enabledExpressions[0]); + } catch (CoreException e) { + Activator.log(e); + } + if (expression == null) { + Activator.log(new Status(Status.ERROR, Activator.PLUGIN_ID, + "Cannot parse enablement expression defined in config provider for " + descriptorTypeId)); //$NON-NLS-1$ + } + } + } public String getDescriptorTypeId() { @@ -40,4 +67,12 @@ public class LaunchConfigProviderInfo { } return provider; } + + public boolean enabled(Object element) throws CoreException { + if (expression == null) + return true; + EvaluationResult result = expression.evaluate(new EvaluationContext(null, element)); + return (result == EvaluationResult.TRUE); + } + } \ No newline at end of file diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchDescriptorTypeInfo.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchDescriptorTypeInfo.java index 61ee75a5dbb..2fcea474e2a 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchDescriptorTypeInfo.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/LaunchDescriptorTypeInfo.java @@ -28,7 +28,9 @@ public class LaunchDescriptorTypeInfo { Activator.log(e); } } + this.element = element; + IConfigurationElement[] enabledExpressions = element.getChildren("enablement");//$NON-NLS-1$ if (enabledExpressions == null || enabledExpressions.length == 0) { Activator.log(new Status(Status.WARNING, Activator.PLUGIN_ID, @@ -36,7 +38,7 @@ public class LaunchDescriptorTypeInfo { } else if (enabledExpressions.length > 1) { Activator.log(new Status(Status.WARNING, Activator.PLUGIN_ID, "Multiple enablement expressions are detected for descriptor type "//$NON-NLS-1$ - + id)); + + id)); } else { try { expression = ExpressionConverter.getDefault().perform(enabledExpressions[0]); @@ -51,7 +53,7 @@ public class LaunchDescriptorTypeInfo { } // Used for testing - public LaunchDescriptorTypeInfo(String id, int priority, ILaunchDescriptorType type) { + LaunchDescriptorTypeInfo(String id, int priority, ILaunchDescriptorType type) { this.id = id; this.priority = priority; this.type = type; @@ -73,10 +75,10 @@ public class LaunchDescriptorTypeInfo { return type; } - public boolean ownsLaunchObject(Object object) throws CoreException { + public boolean enabled(Object launchObject) throws CoreException { if (expression == null) return true; - EvaluationResult result = expression.evaluate(new EvaluationContext(null, object)); + EvaluationResult result = expression.evaluate(new EvaluationContext(null, launchObject)); return (result == EvaluationResult.TRUE); } } \ No newline at end of file diff --git a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/ProjectLaunchObjectProvider.java b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/ProjectLaunchObjectProvider.java index c706cf46a25..8d494062154 100644 --- a/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/ProjectLaunchObjectProvider.java +++ b/bundles/org.eclipse.launchbar.core/src/org/eclipse/launchbar/core/internal/ProjectLaunchObjectProvider.java @@ -25,8 +25,8 @@ import org.eclipse.launchbar.core.ILaunchBarManager; import org.eclipse.launchbar.core.ILaunchObjectProvider; /** - * Injects IProject objects from platform resources into the launch bar model for potential - * project descriptors. + * Injects IProject objects from platform resources into the launch bar model + * for potential project descriptors. */ public class ProjectLaunchObjectProvider implements ILaunchObjectProvider, IResourceChangeListener { private ILaunchBarManager manager; @@ -60,8 +60,11 @@ public class ProjectLaunchObjectProvider implements ILaunchObjectProvider, IReso } else if ((kind & IResourceDelta.REMOVED) != 0) { manager.launchObjectRemoved(project); } else if ((kind & IResourceDelta.CHANGED) != 0) { - // TODO may need to be more concise as to what changes we're looking for - manager.launchObjectChanged(project); + int flags = delta.getFlags(); + // Right now, only care about nature changes + if ((flags & IResourceDelta.DESCRIPTION) != 0) { + manager.launchObjectChanged(project); + } } return false; } else if (res instanceof IFile || res instanceof IFolder) { diff --git a/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/PerTargetLaunchConfigProviderTest.java b/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/PerTargetLaunchConfigProviderTest.java index a2fe64af600..9f59c4d140a 100644 --- a/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/PerTargetLaunchConfigProviderTest.java +++ b/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/PerTargetLaunchConfigProviderTest.java @@ -16,10 +16,10 @@ import static org.junit.Assert.assertNotEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertSame; import static org.junit.Assert.assertTrue; - import static org.mockito.Mockito.doReturn; import static org.mockito.Mockito.mock; import static org.mockito.Mockito.spy; +import static org.mockito.Mockito.verify; import org.eclipse.core.runtime.CoreException; import org.eclipse.debug.core.DebugPlugin; @@ -38,6 +38,7 @@ import org.junit.FixMethodOrder; import org.junit.Test; import org.junit.runners.MethodSorters; +@SuppressWarnings("nls") @FixMethodOrder(MethodSorters.JVM) public class PerTargetLaunchConfigProviderTest { private IRemoteServicesManager remoteServiceManager; @@ -85,16 +86,62 @@ public class PerTargetLaunchConfigProviderTest { } public class PerTargetLaunchConfigProvider1 extends PerTargetLaunchConfigProvider { + public static final String CONNECTION_NAME_ATTR = "connectionName"; + private ILaunchBarManager manager; + @Override public boolean supports(ILaunchDescriptor descriptor, IRemoteConnection target) throws CoreException { return true; } @Override - public ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor, IRemoteConnection target) - throws CoreException { + public ILaunchConfigurationType getLaunchConfigurationType(ILaunchDescriptor descriptor, + IRemoteConnection target) throws CoreException { return launchConfigType; } + + @Override + protected void populateLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target, + ILaunchConfigurationWorkingCopy workingCopy) throws CoreException { + super.populateLaunchConfiguration(descriptor, target, workingCopy); + workingCopy.setAttribute(CONNECTION_NAME_ATTR, target.getName()); + } + + @Override + protected ILaunchDescriptor getLaunchDescriptor(ILaunchConfiguration configuration) throws CoreException { + return descriptor; + } + + @Override + protected IRemoteConnection getLaunchTarget(ILaunchConfiguration configuration) throws CoreException { + String name = configuration.getAttribute(CONNECTION_NAME_ATTR, ""); + if (localTarget.getName().equals(name)) { + return localTarget; + } else if (otherTarget.getName().equals(name)) { + return otherTarget; + } else { + return null; + } + } + + @Override + protected ILaunchBarManager getManager() { + if (manager == null) { + manager = mock(ILaunchBarManager.class); + } + return manager; + } + + @Override + public ILaunchConfiguration getLaunchConfiguration(ILaunchDescriptor descriptor, IRemoteConnection target) + throws CoreException { + ILaunchConfiguration config = super.getLaunchConfiguration(descriptor, target); + // Since this provider isn't hooked in properly, need to manually + // add in the config + launchConfigurationAdded(config); + return config; + } + }; @Test @@ -102,9 +149,7 @@ public class PerTargetLaunchConfigProviderTest { ILaunchConfiguration launchConfig = launchConfigType.newInstance(null, launchName).doSave(); ILaunchConfigurationWorkingCopy launchConfigWC = launchConfig.getWorkingCopy(); provider.populateLaunchConfiguration(descriptor, localTarget, launchConfigWC); - //assertEquals(launchConfig.getName(), launchConfigWC.getAttribute(LaunchBarManager2Test.ATTR_ORIGINAL_NAME, "")); - //assertEquals(provider.getClass().getName(), launchConfigWC.getAttribute(LaunchBarManager2Test.ATTR_PROVIDER_CLASS, "")); - assertTrue(provider.ownsLaunchConfigurationByAttributes(launchConfigWC)); + assertTrue(provider.ownsLaunchConfiguration(launchConfigWC)); } @Test @@ -139,7 +184,8 @@ public class PerTargetLaunchConfigProviderTest { assertNotNull(launchConfiguration1); // reset provider provider = new PerTargetLaunchConfigProvider1(); - provider.launchConfigurationAdded(launchConfiguration1); // simulate provider initialization on startup + // simulate provider initialization on startup + provider.launchConfigurationAdded(launchConfiguration1); ILaunchConfiguration launchConfiguration2 = provider.getLaunchConfiguration(descriptor, localTarget); assertNotNull(launchConfiguration2); assertEquals(launchConfiguration1, launchConfiguration2); @@ -149,7 +195,7 @@ public class PerTargetLaunchConfigProviderTest { public void testGetTarget() throws CoreException { ILaunchConfiguration launchConfiguration1 = provider.getLaunchConfiguration(descriptor, localTarget); assertNotNull(launchConfiguration1); - assertSame(localTarget, provider.getTarget(launchConfiguration1)); + assertSame(localTarget, provider.getLaunchTarget(launchConfiguration1)); } @Test @@ -177,10 +223,10 @@ public class PerTargetLaunchConfigProviderTest { ILaunchConfiguration launchConfiguration1 = provider.getLaunchConfiguration(descriptor, localTarget); assertNotNull(launchConfiguration1); ILaunchConfigurationWorkingCopy wc = launchConfiguration1.getWorkingCopy(); - wc.setAttribute(provider.getConnectionNameAttribute(), otherTarget.getName()); + wc.setAttribute(PerTargetLaunchConfigProvider1.CONNECTION_NAME_ATTR, otherTarget.getName()); wc.doSave(); provider.launchConfigurationChanged(launchConfiguration1); - //provider.launchConfigurationChanged(lc3); + // provider.launchConfigurationChanged(lc3); ILaunchConfiguration launchConfiguration2 = provider.getLaunchConfiguration(descriptor, localTarget); assertNotNull(launchConfiguration2); assertNotEquals(launchConfiguration1, launchConfiguration2); @@ -192,10 +238,14 @@ public class PerTargetLaunchConfigProviderTest { assertNotNull(launchConfiguration1); ILaunchConfigurationWorkingCopy wc = launchConfiguration1.getWorkingCopy(); wc.setAttribute(LaunchBarManager2Test.ATTR_ORIGINAL_NAME, "bla"); - wc.doSave(); + launchConfiguration1 = wc.doSave(); provider.launchConfigurationChanged(launchConfiguration1); // we should have lost ownership assertFalse(provider.ownsLaunchConfiguration(launchConfiguration1)); + verify(provider.manager).launchConfigurationRemoved(launchConfiguration1); + verify(provider.manager).launchConfigurationAdded(launchConfiguration1); + // have to fake out the remove + provider.launchConfigurationRemoved(launchConfiguration1); ILaunchConfiguration launchConfiguration2 = provider.getLaunchConfiguration(descriptor, localTarget); assertNotNull(launchConfiguration2); assertNotEquals(launchConfiguration1, launchConfiguration2); @@ -206,7 +256,6 @@ public class PerTargetLaunchConfigProviderTest { ILaunchConfiguration launchConfiguration1 = provider.getLaunchConfiguration(descriptor, localTarget); assertNotNull(launchConfiguration1); provider.launchDescriptorRemoved(descriptor); - assertEquals(0, provider.getTargetMap(descriptor).size()); assertFalse(provider.ownsLaunchConfiguration(launchConfiguration1)); assertFalse(launchConfiguration1.exists()); } @@ -214,7 +263,6 @@ public class PerTargetLaunchConfigProviderTest { @Test public void testLaunchDescriptorRemoved2() throws CoreException { provider.launchDescriptorRemoved(descriptor); - assertEquals(0, provider.getTargetMap(descriptor).size()); } @Test @@ -222,7 +270,6 @@ public class PerTargetLaunchConfigProviderTest { ILaunchConfiguration launchConfiguration1 = provider.getLaunchConfiguration(descriptor, otherTarget); assertNotNull(launchConfiguration1); provider.launchTargetRemoved(otherTarget); - assertEquals(0, provider.getTargetMap(descriptor).size()); assertFalse(launchConfiguration1.exists()); } @@ -233,7 +280,6 @@ public class PerTargetLaunchConfigProviderTest { ILaunchConfiguration launchConfiguration2 = provider.getLaunchConfiguration(descriptor, localTarget); assertNotNull(launchConfiguration2); provider.launchTargetRemoved(otherTarget); - assertEquals(1, provider.getTargetMap(descriptor).size()); assertFalse(launchConfiguration1.exists()); assertTrue(launchConfiguration2.exists()); } @@ -243,7 +289,6 @@ public class PerTargetLaunchConfigProviderTest { ILaunchConfiguration launchConfiguration1 = provider.getLaunchConfiguration(descriptor, otherTarget); assertNotNull(launchConfiguration1); provider.launchTargetRemoved(localTarget); - assertEquals(1, provider.getTargetMap(descriptor).size()); } @Test @@ -252,7 +297,6 @@ public class PerTargetLaunchConfigProviderTest { assertNotNull(launchConfiguration1); assertTrue(provider.ownsLaunchConfiguration(launchConfiguration1)); launchConfiguration1.delete(); - assertTrue(provider.ownsLaunchConfiguration(launchConfiguration1)); provider.launchConfigurationRemoved(launchConfiguration1); assertFalse(provider.ownsLaunchConfiguration(launchConfiguration1)); } diff --git a/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/internal/LaunchBarManager2Test.java b/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/internal/LaunchBarManager2Test.java index c9fa7fd5dbc..08842f3311d 100644 --- a/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/internal/LaunchBarManager2Test.java +++ b/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/internal/LaunchBarManager2Test.java @@ -16,7 +16,6 @@ import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; import static org.junit.Assert.assertTrue; import static org.junit.Assert.fail; - import static org.mockito.Matchers.any; import static org.mockito.Matchers.anyString; import static org.mockito.Matchers.eq; @@ -129,26 +128,26 @@ public class LaunchBarManager2Test { doReturn(provider).when(element).createExecutableExtension("class"); } - protected ILaunchConfigurationProvider mockProviderElement(String descriptorTypeId, int priority, ILaunchDescriptor descriptor, - IRemoteConnection target, - ILaunchConfiguration config, Object launchObj) throws CoreException { + protected ILaunchConfigurationProvider mockConfigProviderElement(String descriptorTypeId, int priority, + ILaunchDescriptor descriptor, IRemoteConnection target, ILaunchConfiguration config, Object launchObj) + throws CoreException { ILaunchConfigurationProvider provider = mock(ILaunchConfigurationProvider.class); mockProviderElement(descriptorTypeId, priority, provider); doReturn(config.getType()).when(provider).getLaunchConfigurationType(descriptor, target); doReturn(config).when(provider).getLaunchConfiguration(descriptor, target); doReturn(true).when(provider).supports(descriptor, target); - doReturn(true).when(provider).ownsLaunchConfiguration(config); + doReturn(true).when(provider).launchConfigurationAdded(config); return provider; } protected IConfigurationElement mockDescriptorTypeElement(String descriptorTypeId, int priority, - ILaunchDescriptorType descriptorType) - throws CoreException { + ILaunchDescriptorType descriptorType) throws CoreException { IConfigurationElement element = mockElementAndAdd("descriptorType"); doReturn(descriptorTypeId).when(element).getAttribute("id"); doReturn(Integer.toString(priority)).when(element).getAttribute("priority"); doReturn(descriptorType).when(element).createExecutableExtension("class"); - mockEnablementElement(element); + // TODO need a real enablement here, not an empty one + // mockEnablementElement(element); return element; } @@ -179,7 +178,6 @@ public class LaunchBarManager2Test { } protected void mockLaunchObjectOnDescriptor(Object launchObject) throws CoreException { - doReturn(true).when(descriptorType).ownsLaunchObject(launchObject); doReturn(descriptor).when(descriptorType).getDescriptor(launchObject); doReturn(launchObject.toString()).when(descriptor).getName(); } @@ -297,7 +295,7 @@ public class LaunchBarManager2Test { doReturn(descriptorType).when(descriptor).getType(); doReturn(descriptor).when(descriptorType).getDescriptor(launchObject); // configProvider - provider = mockProviderElement(descriptorTypeId, 10, descriptor, otherTarget, launchConfig, launchObject); + provider = mockConfigProviderElement(descriptorTypeId, 10, descriptor, otherTarget, launchConfig, launchObject); mockLaunchObjectOnDescriptor(launchObject); // default descriptor String defaultDescTypeId = "defaultDescType"; @@ -309,7 +307,8 @@ public class LaunchBarManager2Test { @Test public void testDescriptor() throws Exception { // Create a descriptor type and inject an associated object - // Make sure the descriptor is active with the local target and proper mode + // Make sure the descriptor is active with the local target and proper + // mode // Make sure the associated launch config is active too // Mocking manager.launchObjectAdded(launchObject); @@ -327,26 +326,20 @@ public class LaunchBarManager2Test { assertNull(manager.getActiveLaunchMode()); } - @Test - public void testAddDescriptorTypeBad() throws CoreException { - doThrow(new NullPointerException()).when(descriptorType).ownsLaunchObject(any()); - manager.launchObjectAdded("aaa"); - verify(descriptorType).ownsLaunchObject(any()); - } - @Test public void testAddConfigMappingTwo() throws CoreException { basicSetupOnly(); IRemoteConnection target = mockRemoteConnection("t2"); - mockProviderElement(descriptorTypeId, 10, descriptor, target, launchConfig, launchObject); + mockConfigProviderElement(descriptorTypeId, 10, descriptor, target, launchConfig, launchObject); // now create another lc type, which is not registered in config type ILaunchConfigurationType lctype2 = mockLCType("lctypeid2"); ILaunchConfiguration lc2 = mockLC("bla2", lctype2); ConfigBasedLaunchDescriptor desc2 = new ConfigBasedLaunchDescriptor(descriptorType, lc2); - mockProviderElement(descriptorTypeId, 10, desc2, target, lc2, lc2); + mockConfigProviderElement(descriptorTypeId, 10, desc2, target, lc2, lc2); init(); manager.launchObjectAdded(launchObject); - // it return original lctype because we did not associate this dynmaically + // it return original lctype because we did not associate this + // dynmaically assertEquals(launchConfigType, manager.getLaunchConfigurationType(descriptor, target)); } @@ -354,10 +347,10 @@ public class LaunchBarManager2Test { public void testAddConfigProviderTwo2() throws CoreException { basicSetupOnly(); IRemoteConnection target = mockRemoteConnection("t2"); - mockProviderElement(descriptorTypeId, 15, descriptor, target, launchConfig, launchObject); + mockConfigProviderElement(descriptorTypeId, 15, descriptor, target, launchConfig, launchObject); ILaunchConfigurationType lctype2 = mockLCType("lctypeid2"); ILaunchConfiguration lc2 = mockLC("lc2", lctype2); - mockProviderElement(descriptorTypeId, 20, descriptor, target, lc2, launchObject); + mockConfigProviderElement(descriptorTypeId, 20, descriptor, target, lc2, launchObject); init(); manager.launchObjectAdded(launchObject); assertEquals(lctype2, manager.getLaunchConfigurationType(descriptor, target)); @@ -390,7 +383,7 @@ public class LaunchBarManager2Test { basicSetupOnly(); elements.clear(); mockDescriptorTypeElement(descriptorTypeId, 10, descriptorType); - mockProviderElement(descriptorTypeId, 10, descriptor, localTarget, launchConfig, launchObject); + mockConfigProviderElement(descriptorTypeId, 10, descriptor, localTarget, launchConfig, launchObject); init(); manager.launchObjectAdded(launchObject); ILaunchDescriptor desc = manager.getActiveLaunchDescriptor(); @@ -420,30 +413,36 @@ public class LaunchBarManager2Test { } // - // public void testGetLaunchDescriptorsSort() { - // final ILaunchDescriptor res[] = new ILaunchDescriptor[1]; - // manager.addTargetType(targetType); - // ConfigBasedLaunchDescriptorType descType1 = new ConfigBasedLaunchDescriptorType("id1", lctype.getIdentifier()); - // ConfigBasedLaunchDescriptorType descType2 = new ConfigBasedLaunchDescriptorType("id2", lctype.getIdentifier()) { - // @Override - // public ILaunchDescriptor getDescriptor(Object element) { - // return res[0] = super.getDescriptor(element); - // } - // }; - // ConfigBasedLaunchDescriptorType descType3 = new ConfigBasedLaunchDescriptorType("id3", lctype.getIdentifier()); - // manager.addDescriptorType(descType1, 3); - // manager.addDescriptorType(descType2, 5); - // manager.addDescriptorType(descType3, 1); - // manager.addConfigProvider(descType1.getId(), targetType.getId(), true, provider); - // manager.addConfigProvider(descType2.getId(), targetType.getId(), true, provider); - // manager.addConfigProvider(descType3.getId(), targetType.getId(), true, provider); - // targetType.targets.add(mytarget); - // manager.launchObjectAdded(launchObject); - // ILaunchDescriptor[] launchDescriptors = manager.getLaunchDescriptors(); - // assertEquals(1, launchDescriptors.length); - // assertNotNull(launchDescriptors[0]); - // assertSame(res[0], launchDescriptors[0]); - // } + // public void testGetLaunchDescriptorsSort() { + // final ILaunchDescriptor res[] = new ILaunchDescriptor[1]; + // manager.addTargetType(targetType); + // ConfigBasedLaunchDescriptorType descType1 = new + // ConfigBasedLaunchDescriptorType("id1", lctype.getIdentifier()); + // ConfigBasedLaunchDescriptorType descType2 = new + // ConfigBasedLaunchDescriptorType("id2", lctype.getIdentifier()) { + // @Override + // public ILaunchDescriptor getDescriptor(Object element) { + // return res[0] = super.getDescriptor(element); + // } + // }; + // ConfigBasedLaunchDescriptorType descType3 = new + // ConfigBasedLaunchDescriptorType("id3", lctype.getIdentifier()); + // manager.addDescriptorType(descType1, 3); + // manager.addDescriptorType(descType2, 5); + // manager.addDescriptorType(descType3, 1); + // manager.addConfigProvider(descType1.getId(), targetType.getId(), true, + // provider); + // manager.addConfigProvider(descType2.getId(), targetType.getId(), true, + // provider); + // manager.addConfigProvider(descType3.getId(), targetType.getId(), true, + // provider); + // targetType.targets.add(mytarget); + // manager.launchObjectAdded(launchObject); + // ILaunchDescriptor[] launchDescriptors = manager.getLaunchDescriptors(); + // assertEquals(1, launchDescriptors.length); + // assertNotNull(launchDescriptors[0]); + // assertSame(res[0], launchDescriptors[0]); + // } // @Test public void testLaunchObjectAdded() throws CoreException { @@ -481,6 +480,7 @@ public class LaunchBarManager2Test { when(project.getType()).thenReturn(IResource.PROJECT); return project; } + public static final String ATTR_PROJECT_NAME = "org.eclipse.cdt.launch" + ".PROJECT_ATTR"; public static final String ATTR_PROGRAM_NAME = "org.eclipse.cdt.launch" + ".PROGRAM_NAME"; @@ -547,11 +547,6 @@ public class LaunchBarManager2Test { } public class ProjectBasedLaunchDescriptorType implements ILaunchDescriptorType { - @Override - public boolean ownsLaunchObject(Object launchObject) throws CoreException { - return launchObject instanceof IProject; - } - @Override public ILaunchDescriptor getDescriptor(Object launchObject) throws CoreException { return new ProjectLaunchDescriptor(this, (IProject) launchObject); @@ -561,8 +556,11 @@ public class LaunchBarManager2Test { return "pbtype"; } } - public static final String ATTR_ORIGINAL_NAME = org.eclipse.launchbar.core.internal.Activator.PLUGIN_ID + ".originalName"; //$NON-NLS-1$ - public static final String ATTR_PROVIDER_CLASS = org.eclipse.launchbar.core.internal.Activator.PLUGIN_ID + ".providerClass"; //$NON-NLS-1$ + + public static final String ATTR_ORIGINAL_NAME = org.eclipse.launchbar.core.internal.Activator.PLUGIN_ID + + ".originalName"; //$NON-NLS-1$ + public static final String ATTR_PROVIDER_CLASS = org.eclipse.launchbar.core.internal.Activator.PLUGIN_ID + + ".providerClass"; //$NON-NLS-1$ protected void projectMappingSetup() throws CoreException { descriptorType = new ProjectBasedLaunchDescriptorType(); @@ -571,7 +569,8 @@ public class LaunchBarManager2Test { descriptor = new ProjectLaunchDescriptor(descriptorType, aaa); // setup some stuff mockDescriptorTypeElement(descriptorTypeId, 10, descriptorType); - //lc = provider.createLaunchConfiguration(lman, descType.getDescriptor(aaa)); + // lc = provider.createLaunchConfiguration(lman, + // descType.getDescriptor(aaa)); mockLCProject(launchConfig, aaa); mockLCAttribute(launchConfig, ATTR_ORIGINAL_NAME, aaa.getName()); assertEquals(0, manager.getLaunchDescriptors().length); @@ -586,6 +585,16 @@ public class LaunchBarManager2Test { public boolean ownsLaunchConfiguration(ILaunchConfiguration configuration) throws CoreException { return configuration == launchConfig; } + + @Override + protected ILaunchDescriptor getLaunchDescriptor(ILaunchConfiguration configuration) throws CoreException { + return descriptor; + } + + @Override + protected IRemoteConnection getLaunchTarget(ILaunchConfiguration configuration) throws CoreException { + return localTarget; + } }; mockProviderElement(descriptorTypeId, 10, provider); mockLCAttribute(launchConfig, ATTR_PROVIDER_CLASS, provider.getClass().getName()); @@ -635,10 +644,10 @@ public class LaunchBarManager2Test { @Test public void testLaunchObjectAddedBadDescriptor() throws CoreException { - doThrow(new NullPointerException()).when(descriptorType).ownsLaunchObject(any()); + doThrow(new NullPointerException()).when(descriptorType).getDescriptor(any()); // check events manager.launchObjectAdded(launchObject); - verify(descriptorType).ownsLaunchObject(launchObject); + verify(descriptorType).getDescriptor(launchObject); } @Test @@ -651,7 +660,7 @@ public class LaunchBarManager2Test { @Test public void testLaunchObjectRemoveBadDescriptor() throws CoreException { - doThrow(new NullPointerException()).when(descriptorType).ownsLaunchObject(any()); + doThrow(new NullPointerException()).when(descriptorType).getDescriptor(any()); // check events manager.launchObjectRemoved(launchObject); } @@ -894,7 +903,7 @@ public class LaunchBarManager2Test { ILaunchMode mode = mockLaunchModes(launchConfigType, "foo")[0]; manager.launchObjectAdded(launchObject); manager.launchConfigurationAdded(launchConfig); - verify(provider).ownsLaunchConfiguration(launchConfig); + verify(provider).launchConfigurationAdded(launchConfig); ILaunchDescriptor[] launchDescriptors = manager.getLaunchDescriptors(); assertEquals(1, launchDescriptors.length); assertNotNull(launchDescriptors[0]); @@ -910,7 +919,7 @@ public class LaunchBarManager2Test { ILaunchConfigurationType lctype2 = mockLCType("lctype2"); ILaunchConfiguration lc2 = mockLC("lc2", lctype2); manager.launchConfigurationAdded(lc2); - //verify(provider).launchConfigurationAdded(lc2); + // verify(provider).launchConfigurationAdded(lc2); ILaunchDescriptor[] launchDescriptors = manager.getLaunchDescriptors(); assertEquals(1, launchDescriptors.length); assertNotNull(launchDescriptors[0]); @@ -921,10 +930,9 @@ public class LaunchBarManager2Test { @Test public void testLaunchConfigurationAddedBad() throws CoreException { - doThrow(new NullPointerException()).when(provider).ownsLaunchConfiguration(any(ILaunchConfiguration.class)); + doThrow(new NullPointerException()).when(provider).launchConfigurationAdded(any(ILaunchConfiguration.class)); manager.launchConfigurationAdded(launchConfig); verify(provider).launchConfigurationAdded(launchConfig); - verify(provider).ownsLaunchConfiguration(launchConfig); } @Test @@ -958,10 +966,13 @@ public class LaunchBarManager2Test { mockSubElement(enablement, new IConfigurationElement[] { instance }); doReturn("java.lang.Integer").when(instance).getAttribute("value"); init(); - assertNull(manager.launchObjectAdded(launchObject)); // this will be refused by enablement expression - assertNull(manager.launchObjectAdded(1)); // we programmatically refuse this + // this will be refused by enablement expression + assertNull(manager.launchObjectAdded(launchObject)); + // we programmatically refuse this + assertNull(manager.launchObjectAdded(1)); mockLaunchObjectOnDescriptor(1); - assertNotNull(manager.launchObjectAdded(1)); // now we both good programmatically and in expression in extension + // now we both good programmatically and in expression in extension + assertNotNull(manager.launchObjectAdded(1)); } } diff --git a/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/internal/LaunchBarManagerTest.java b/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/internal/LaunchBarManagerTest.java index 81bce296aa4..f821d43e1fb 100644 --- a/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/internal/LaunchBarManagerTest.java +++ b/tests/org.eclipse.launchbar.core.tests/src/org/eclipse/launchbar/core/internal/LaunchBarManagerTest.java @@ -3,7 +3,6 @@ package org.eclipse.launchbar.core.internal; import static org.junit.Assert.assertEquals; import static org.junit.Assert.assertNotNull; import static org.junit.Assert.assertNull; - import static org.mockito.Matchers.any; import static org.mockito.Matchers.anyString; import static org.mockito.Matchers.eq; @@ -46,15 +45,17 @@ public class LaunchBarManagerTest { @Test public void defaultTest() throws Exception { - // Create a launch config, make sure default mode and local target are active + // Create a launch config, make sure default mode and local target are + // active // And that that config is the active config. - + // Mocking ILaunchConfigurationType launchConfigType = mock(ILaunchConfigurationType.class); ILaunchConfiguration launchConfig = mock(ILaunchConfiguration.class); String launchConfigName = "launchConfig"; doReturn(launchConfigName).when(launchConfig).getName(); - doReturn(launchConfigName).when(launchConfig).getAttribute(eq("org.eclipse.launchbar.core.originalName"), anyString()); + doReturn(launchConfigName).when(launchConfig).getAttribute(eq("org.eclipse.launchbar.core.originalName"), + anyString()); doReturn("").when(launchConfig).getAttribute(eq("org.eclipse.launchbar.core.providerClass"), anyString()); doReturn(true).when(launchConfigType).isPublic(); doReturn(launchConfigType).when(launchConfig).getType(); @@ -80,25 +81,25 @@ public class LaunchBarManagerTest { assertNotNull(manager.getActiveLaunchMode()); assertEquals("run", manager.getActiveLaunchMode().getIdentifier()); - + assertEquals(launchConfig, manager.getActiveLaunchConfiguration()); } @Test - @SuppressWarnings("deprecation") public void descriptorTest() throws Exception { // Create a descriptor type and inject an associated object - // Make sure the descriptor is active with the local target and proper mode + // Make sure the descriptor is active with the local target and proper + // mode // Make sure the associated launch config is active too // Mocking final IExtensionPoint extensionPoint = mock(IExtensionPoint.class); IExtension extension = mock(IExtension.class); doReturn(new IExtension[] { extension }).when(extensionPoint).getExtensions(); - + List elements = new ArrayList<>(); IConfigurationElement element; - + // fake launch object String launchObject = "fakeObject"; @@ -110,7 +111,6 @@ public class LaunchBarManagerTest { doReturn(descriptorTypeId).when(element).getAttribute("id"); ILaunchDescriptorType descriptorType = mock(ILaunchDescriptorType.class); doReturn(descriptorType).when(element).createExecutableExtension("class"); - doReturn(true).when(descriptorType).ownsLaunchObject(launchObject); ILaunchDescriptor descriptor = mock(ILaunchDescriptor.class); doReturn(descriptor).when(descriptorType).getDescriptor(launchObject); doReturn(descriptorType).when(descriptor).getType(); @@ -142,13 +142,15 @@ public class LaunchBarManagerTest { doReturn("configProvider").when(element).getName(); doReturn(descriptorTypeId).when(element).getAttribute("descriptorType"); doReturn("10").when(element).getAttribute("priority"); - + ILaunchConfigurationProvider configProvider = mock(ILaunchConfigurationProvider.class); doReturn(configProvider).when(element).createExecutableExtension("class"); ILaunchConfiguration launchConfig = mock(ILaunchConfiguration.class); - doReturn(launchConfig).when(configProvider).getLaunchConfiguration(eq(descriptor), any(IRemoteConnection.class)); - doReturn(launchConfigType).when(configProvider).getLaunchConfigurationType(any(ILaunchDescriptor.class), any(IRemoteConnection.class)); + doReturn(launchConfig).when(configProvider).getLaunchConfiguration(eq(descriptor), + any(IRemoteConnection.class)); + doReturn(launchConfigType).when(configProvider).getLaunchConfigurationType(any(ILaunchDescriptor.class), + any(IRemoteConnection.class)); doAnswer(new Answer() { @Override public Boolean answer(InvocationOnMock invocation) throws Throwable { @@ -158,13 +160,14 @@ public class LaunchBarManagerTest { }).when(configProvider).supports(eq(descriptor), any(IRemoteConnection.class)); doReturn(elements.toArray(new IConfigurationElement[0])).when(extension).getConfigurationElements(); - + // Now inject the launch object LaunchBarManager manager = new LaunchBarManager(false) { @Override IExtensionPoint getExtensionPoint() throws CoreException { return extensionPoint; } + @Override ILaunchManager getLaunchManager() { return launchManager; @@ -183,10 +186,13 @@ public class LaunchBarManagerTest { assertEquals(launchConfig, manager.getActiveLaunchConfiguration()); } - // TODO - test that changing active target type produces a different launch config type + // TODO - test that changing active target type produces a different launch + // config type // TODO - test that settings are maintained after a restart - // TODO - test that two target types that map to the same desc type and config type share configs - // TODO - test duplicating a config. make sure it's default desc and same targets + // TODO - test that two target types that map to the same desc type and + // config type share configs + // TODO - test duplicating a config. make sure it's default desc and same + // targets // TODO - test project descriptors and stuff // TODO - test descriptor takeovers (new descriptors on launchObjectChange