Released eclipse-base 3.3.0 and eclipse-wtp 3.15.2 (#533)

Added support of plugin extensions without activator to eclipse-base.
Added configuration via single interface implementation (functional configuration is marked deprecated).
Racing conditions in eclipse-wtp fixed. New approach disallows multiple instantiations with different configurations.

Author: fvgh

_ext/eclipse-base/CHANGES.md

@@ -1,23 +1,28 @@
 # spotless-eclipse-base
 
-### Version 3.2.1 - September 3rd 2019 ([artifact]([jcenter](https://bintray.com/diffplug/opensource/spotless-eclipse-base)))
+We adhere to the [keepachangelog](https://keepachangelog.com/en/1.0.0/) format (starting after version `3.2.1`).
 
-* Fixed deletion of temporary workspace. ([#447](https://github.com/diffplug/spotless/issues/447))
+## [Unreleased]
 
-### Version 3.2.0 - June 30th 2019 ([artifact]([jcenter](https://bintray.com/diffplug/opensource/spotless-eclipse-base)))
+## [3.3.0] - 2020-03-04
+### Added
+* Added support of plugin extensions without activator ([#533](https://github.com/diffplug/spotless/issues/533)). Required since `org.eclipse.core.filesystem` version `1.7.600` (see
+[Bug 550548](https://bugs.eclipse.org/bugs/show_bug.cgi?id=550548))
+* Updated configuration via single interface implementation. Functional based configuration still supported.
 
-* Added support of Eclipse 4.12 framework wiring. ([#413](https://github.com/diffplug/spotless/issues/413))
+## [3.2.1] - 2019-09-03
+* Fixed deletion of temporary workspace. ([#447](https://github.com/diffplug/spotless/issues/447))
 
-### Version 3.1.1 - June 4th 2019 ([artifact]([jcenter](https://bintray.com/diffplug/opensource/spotless-eclipse-base)))
+## [3.2.0] - 2019-06-30
+* Added support of Eclipse 4.12 framework wiring. ([#413](https://github.com/diffplug/spotless/issues/413))
 
+## [3.1.1] - 2019-06-04
 * Fixed problem handling URL escaped characters in JAR file location. ([#401](https://github.com/diffplug/spotless/issues/401))
 
-### Version 3.1.0 - February 10th 2019 ([artifact]([jcenter](https://bintray.com/diffplug/opensource/spotless-eclipse-base)))
-
+## [3.1.0] - 2019-02-10
 * Added logging service based on SLF4J. ([#236](https://github.com/diffplug/spotless/issues/236))
 * Updated internal interfaces to support `org.eclipse.osgi` version 3.13.
 * Corrected documentation of version number usage in `gradle.properties`.
 
-### Version 3.0.0 - July 18th 2018 ([artifact]([jcenter](https://bintray.com/diffplug/opensource/spotless-eclipse-base)))
-
+## [3.0.0] - 2018-06-18
 * Initial release!

_ext/eclipse-base/README.md

@@ -32,8 +32,7 @@ public EclipseFormatterStepImpl(Properties settings) throws Exception {
 ```
 
 The framework also supports fat JARs, providing multiple plugins.
-In this cases the resources required by plugins, especially the `META-INF` and plugin information, must be located in locations unique
-to the plugin.
+In this cases the resources required by plugins, especially the `META-INF` and plugin information, must be located in locations unique to the plugin.
 For this purpose the framework expects that these resources are stored in a sub-directory
 which has the name of the package containing the plugin. For example in case the JDT plugin
 is included in your formatter fat JAR, the directory structure should be:

_ext/eclipse-base/build.gradle

@@ -1,5 +1,5 @@
 apply from: rootProject.file('_ext/gradle/java-setup.gradle')
-apply from: rootProject.file('_ext/gradle/java-publish.gradle')
+apply from: rootProject.file('gradle/java-publish.gradle')
 
 ext {
 	developers = [

_ext/eclipse-base/gradle.properties

@@ -1,7 +1,6 @@
 # Mayor versions correspond to the supported Eclipse core version.
 # Minor version is incremented for features or incompatible changes (including changes to supported dependency versions).
 # Patch version is incremented for backward compatible patches of this library.
-version=3.2.1
 artifactId=spotless-eclipse-base
 description=Eclipse bundle controller and services for Spotless
 

_ext/eclipse-base/src/main/java/com/diffplug/spotless/extra/eclipse/base/SpotlessEclipseConfig.java

@@ -0,0 +1,43 @@
+/*
+ * Copyright 2016 DiffPlug
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.diffplug.spotless.extra.eclipse.base;
+
+/**
+ * Obtain configuration for Eclipse framework setup
+ * <p>
+ * The setup consitst of 4 phases:
+ * <ol>
+ * <li>Registration of framework bundles</li>
+ * <li>Registration of servicves</li>
+ * <li>Resitration of extension points, activation of bundles/plugins</li>
+ * <li>Customize bundle/plugin configuration</li>
+ * </ol>
+ */
+public interface SpotlessEclipseConfig {
+	default public void registerBundles(SpotlessEclipseCoreConfig config) {
+		config.applyDefault();
+	}
+
+	default public void registerServices(SpotlessEclipseServiceConfig config) {
+		config.applyDefault();
+	}
+
+	default public void activatePlugins(SpotlessEclipsePluginConfig config) {
+		config.applyDefault();
+	}
+
+	default public void customize() {}
+}

_ext/eclipse-base/src/main/java/com/diffplug/spotless/extra/eclipse/base/SpotlessEclipseCoreConfig.java

@@ -32,6 +32,11 @@
  */
 public class SpotlessEclipseCoreConfig extends BundleConfig<SpotlessEclipseFramework.DefaultBundles> {
 
+	/**
+	 * Don't instantiate and call {@link SpotlessEclipseConfig} directly.
+	 * Registered bundles should only be instantiated once, since
+	 * older bundles still abusing singletons for access.
+	 */
 	SpotlessEclipseCoreConfig() {}
 
 	@Override

_ext/eclipse-base/src/main/java/com/diffplug/spotless/extra/eclipse/base/SpotlessEclipseFramework.java

@@ -144,6 +144,7 @@ private static <T> T createInstance(Class<? extends T> clazz) {
 	 * If there is already a an instance, the call is ignored.
 	 * @return False if the {@link SpotlessEclipseFramework} instance already exists, true otherwise.
 	 * @throws BundleException Throws exception in case the setup failed.
+	 * @deprecated  Use {@link #setup(SpotlessEclipseConfig)} instead.
 	 */
 	public synchronized static boolean setup() throws BundleException {
 		return setup(plugins -> plugins.applyDefault());
@@ -156,6 +157,7 @@ public synchronized static boolean setup() throws BundleException {
 	 * @param plugins Eclipse plugins (which are also OSGi bundles) to start
 	 * @return False if the {@link SpotlessEclipseFramework} instance already exists, true otherwise.
 	 * @throws BundleException Throws exception in case the setup failed.
+	 * @deprecated  Use {@link #setup(SpotlessEclipseConfig)} instead.
 	 */
 	public synchronized static boolean setup(Consumer<SpotlessEclipsePluginConfig> plugins) throws BundleException {
 		return setup(config -> config.applyDefault(), plugins);
@@ -168,6 +170,7 @@ public synchronized static boolean setup(Consumer<SpotlessEclipsePluginConfig> p
 	 * @param plugins Eclipse plugins (which are also OSGi bundles) to start
 	 * @return False if the {@link SpotlessEclipseFramework} instance already exists, true otherwise.
 	 * @throws BundleException Throws exception in case the setup failed.
+	 * @deprecated  Use {@link #setup(SpotlessEclipseConfig)} instead.
 	 */
 	public synchronized static boolean setup(Consumer<SpotlessEclipseServiceConfig> config, Consumer<SpotlessEclipsePluginConfig> plugins) throws BundleException {
 		return setup(core -> core.applyDefault(), config, plugins);
@@ -177,76 +180,98 @@ public synchronized static boolean setup(Consumer<SpotlessEclipseServiceConfig>
 	 * Creates and configures a new {@link SpotlessEclipseFramework} if there is none.
 	 * If there is already a an instance, the call is ignored.
 	 * @param core Activators of core bundles
-	 * @param config Framework service configuration
+	 * @param services Framework service configuration
 	 * @param plugins Eclipse plugins to start
 	 * @return False if the {@link SpotlessEclipseFramework} instance already exists, true otherwise.
 	 * @throws BundleException Throws exception in case the setup failed.
+	 * @deprecated  Use {@link #setup(SpotlessEclipseConfig)} instead.
 	 */
-	public synchronized static boolean setup(Consumer<SpotlessEclipseCoreConfig> core, Consumer<SpotlessEclipseServiceConfig> config, Consumer<SpotlessEclipsePluginConfig> plugins) throws BundleException {
+	public synchronized static boolean setup(Consumer<SpotlessEclipseCoreConfig> core, Consumer<SpotlessEclipseServiceConfig> services, Consumer<SpotlessEclipsePluginConfig> plugins) throws BundleException {
 		if (null != INSTANCE) {
 			return false;
 		}
+		setup(new SpotlessEclipseConfig() {
+			@Override
+			public void registerBundles(SpotlessEclipseCoreConfig config) {
+				core.accept(config);
+			}
+
+			@Override
+			public void registerServices(SpotlessEclipseServiceConfig config) {
+				services.accept(config);
+			}
 
-		SpotlessEclipseCoreConfig coreConfig = new SpotlessEclipseCoreConfig();
-		core.accept(coreConfig);
+			@Override
+			public void activatePlugins(SpotlessEclipsePluginConfig config) {
+				plugins.accept(config);
+			}
+		});
+		return true;
+	}
 
-		INSTANCE = new SpotlessEclipseFramework(coreConfig);
-		config.accept(INSTANCE.getServiceConfig());
+	/**
+	 * Creates and configures a new {@link SpotlessEclipseFramework} if there is none.
+	 * If there is already a an instance, the call is ignored.
+	 * @param config Configuration
+	 * @throws BundleException Throws exception in case the setup failed.
+	 */
+	public synchronized static void setup(SpotlessEclipseConfig config) throws BundleException {
+		if (null == INSTANCE) {
+			INSTANCE = new SpotlessEclipseFramework();
+			config.registerServices(INSTANCE.getServiceConfig());
+
+			SpotlessEclipseCoreConfig coreConfig = new SpotlessEclipseCoreConfig();
+			config.registerBundles(coreConfig);
+			INSTANCE.startCoreBundles(coreConfig);
+
+			SpotlessEclipsePluginConfig pluginConfig = new SpotlessEclipsePluginConfig();
+			config.activatePlugins(pluginConfig);
+			for (Class<?> extension : pluginConfig.getExtensions()) {
+				INSTANCE.addExtension(extension);
+			}
+			for (BundleConfig.Entry plugin : pluginConfig.get()) {
+				INSTANCE.addPlugin(plugin.state, plugin.activator);
+			}
 
-		SpotlessEclipsePluginConfig pluginConfig = new SpotlessEclipsePluginConfig();
-		plugins.accept(pluginConfig);
-		for (BundleConfig.Entry plugin : pluginConfig.get()) {
-			INSTANCE.addPlugin(plugin.state, plugin.activator);
+			config.customize();
 		}
-		return true;
 	}
 
 	private final Function<Bundle, BundleException> registry;
 	private final BundleController controller;
-	private final SpotlessEclipseCoreConfig coreConfig;
-	private boolean coreConfigStarted;
 
-	private SpotlessEclipseFramework(SpotlessEclipseCoreConfig coreConfig) throws BundleException {
+	private SpotlessEclipseFramework() throws BundleException {
 
 		controller = new BundleController();
 		registry = (pluginBundle) -> {
 			return PluginRegistrar.register(pluginBundle);
 		};
-
-		this.coreConfig = coreConfig;
-		coreConfigStarted = false;
 	}
 
-	/** Get framework service configuration */
 	private SpotlessEclipseServiceConfig getServiceConfig() {
 		return controller.getServices();
 	}
 
-	/** Add a plugin to the framework. */
+	private void addExtension(Class<?> clazzInBundleJar) throws BundleException {
+		controller.addBundle(clazzInBundleJar, registry);
+	}
+
 	private void addPlugin(int state, BundleActivator plugin) throws BundleException {
-		if (!coreConfigStarted) {
-			//The SAXParserFactory.class is required for parsing the plugin XML files
-			addMandatoryServiceIfMissing(SAXParserFactory.class, SAXParserFactory.newInstance());
-			/*
-			 * Since org.eclipse.core.runtime version 3.15.300, the Eclipse bundle look-up is accomplished
-			 * via the wiring framework, which requires a stat of the InternalPlatform.
-			 * The internal platform initialization is customized by the services
-			 * registered to the controller.
-			 */
-			InternalPlatform.getDefault().start(controller);
-			startFrameworkBundles();
-			coreConfigStarted = true;
-		}
 		controller.addBundle(state, plugin, registry);
 	}
 
-	private <S> void addMandatoryServiceIfMissing(Class<S> interfaceClass, S service) {
-		if (null == controller.getServiceReference(interfaceClass)) {
-			controller.getServices().add(interfaceClass, service);
-		}
-	}
+	private void startCoreBundles(SpotlessEclipseCoreConfig coreConfig) throws BundleException {
+		//The SAXParserFactory.class is required for parsing the plugin XML files
+		addMandatoryServiceIfMissing(SAXParserFactory.class, SAXParserFactory.newInstance());
+
+		/*
+		 * Since org.eclipse.core.runtime version 3.15.300, the Eclipse bundle look-up is accomplished
+		 * via the wiring framework, which requires starting the InternalPlatform.
+		 * The internal platform initialization is customized by the services
+		 * registered to the controller.
+		 */
+		InternalPlatform.getDefault().start(controller);
 
-	private void startFrameworkBundles() throws BundleException {
 		for (BundleConfig.Entry coreBundle : coreConfig.get()) {
 			try {
 				BundleContext context = controller.createContext(coreBundle.state);
@@ -257,4 +282,9 @@ private void startFrameworkBundles() throws BundleException {
 		}
 	}
 
+	private <S> void addMandatoryServiceIfMissing(Class<S> interfaceClass, S service) {
+		if (null == controller.getServiceReference(interfaceClass)) {
+			controller.getServices().add(interfaceClass, service);
+		}
+	}
 }

_ext/eclipse-base/src/main/java/com/diffplug/spotless/extra/eclipse/base/SpotlessEclipsePluginConfig.java

@@ -15,6 +15,11 @@
  */
 package com.diffplug.spotless.extra.eclipse.base;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Objects;
+
 import org.osgi.framework.Bundle;
 import org.osgi.framework.BundleActivator;
 
@@ -30,9 +35,42 @@
  * Note that a plugin does not necessarily derive from the
  * Eclipse {@link org.eclipse.core.runtime.Plugin} class.
  * </p>
+ * <p>
+ * Some plugins are pure extensions without any activator.
+ * For resource and plugin information lookup, a class can be
+ * specified which is in the JAR containing the resources and
+ * plugin information. This lookup procedure also supports
+ * fat JAR lookups as described in the ReadMe.md.
+ * </p>
  * @see org.eclipse.core.runtime.RegistryFactory
  */
 public class SpotlessEclipsePluginConfig extends BundleConfig<SpotlessEclipseFramework.DefaultPlugins> {
+	private final List<Class<?>> extensions;
+
+	/**
+	 * Don't instantiate and call {@link SpotlessEclipseConfig} directly.
+	 * Registered plugins and extensions should only be instantiated once, since
+	 * some still abusing singletons for access.
+	 */
+	SpotlessEclipsePluginConfig() {
+		extensions = new ArrayList<>();
+	}
+
+	/** Add an extension plugin, identified by a class of the plugin. */
+	public void add(Class<?> extensionClass) {
+		Objects.requireNonNull(extensionClass, "Plugin extension class must nor be null");
+		extensions.add(extensionClass);
+	}
+
+	/** Add a set of default bundles with their default states */
+	public void add(Class<?>... extensionClasses) {
+		Arrays.asList(extensionClasses).forEach(extensionClass -> add(extensionClass));
+	}
+
+	/** Returns the current configuration */
+	public List<Class<?>> getExtensions() {
+		return extensions;
+	}
 
 	@Override
 	public void applyDefault() {