diff --git a/bundles/org.eclipse.equinox.transforms.hook/META-INF/MANIFEST.MF b/bundles/org.eclipse.equinox.transforms.hook/META-INF/MANIFEST.MF
index ff6b0b1cf4e..5d645feb8d5 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/META-INF/MANIFEST.MF
+++ b/bundles/org.eclipse.equinox.transforms.hook/META-INF/MANIFEST.MF
@@ -3,7 +3,7 @@ Bundle-ManifestVersion: 2
 Bundle-Name: %bundleName
 Bundle-Vendor: %providerName
 Bundle-SymbolicName: org.eclipse.equinox.transforms.hook
-Bundle-Version: 1.3.300.qualifier
+Bundle-Version: 1.3.400.qualifier
 Fragment-Host: org.eclipse.osgi;bundle-version="[3.10.0,4.0.0)"
 Bundle-RequiredExecutionEnvironment: JavaSE-1.8
 Bundle-Localization: transformsHook
diff --git a/bundles/org.eclipse.equinox.transforms.hook/about.html b/bundles/org.eclipse.equinox.transforms.hook/about.html
index 164f781a8fd..8eee37d4705 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/about.html
+++ b/bundles/org.eclipse.equinox.transforms.hook/about.html
@@ -33,4 +33,4 @@ <h3>License</h3>
 	</p>
 
 </body>
-</html>
\ No newline at end of file
+</html>
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/CSVParser.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/CSVParser.java
index f54925eec1d..cde34ccda88 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/CSVParser.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/CSVParser.java
@@ -24,16 +24,22 @@
 import org.eclipse.osgi.internal.log.EquinoxLogServices;
 
 /**
- * This class is used by the transformer hook to parse urls provided by transform developers that specifies the particular transforms that should be utilized for a particular transformer.  
- * TODO: factor this out into a new type of service the transformer uses.  Then there could be CSV transforms, programatic transforms, etc.
+ * This class is used by the transformer hook to parse urls provided by
+ * transform developers that specifies the particular transforms that should be
+ * utilized for a particular transformer. TODO: factor this out into a new type
+ * of service the transformer uses. Then there could be CSV transforms,
+ * programatic transforms, etc.
  */
 public class CSVParser {
 
 	/**
-	 * Parse the given url as a CSV file containing transform tuples.  The tuples have the form:
+	 * Parse the given url as a CSV file containing transform tuples. The tuples
+	 * have the form:
+	 * 
 	 * <pre>
 	 * bundleRegex,pathRegex,transformerResource
-	 * </pre> 
+	 * </pre>
+	 * 
 	 * @param transformMapURL the map url
 	 * @return an array of tuples derived from the contents of the file
 	 * @throws IOException thrown if there are issues parsing the file
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/LazyInputStream.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/LazyInputStream.java
index a2aaff2c62b..0585227e378 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/LazyInputStream.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/LazyInputStream.java
@@ -18,8 +18,9 @@
 import java.io.InputStream;
 
 /**
- * An input stream that is based off of another stream.  
- * This other stream is provided as needed by an {@link InputStreamProvider} so that the underlying stream is not eagerly loaded.
+ * An input stream that is based off of another stream. This other stream is
+ * provided as needed by an {@link InputStreamProvider} so that the underlying
+ * stream is not eagerly loaded.
  */
 public class LazyInputStream extends InputStream {
 
@@ -29,7 +30,8 @@ public class LazyInputStream extends InputStream {
 
 	/**
 	 * Construct a new lazy stream based off the given provider.
-	 * @param provider the input stream provider.  Must not be <code>null</code>.
+	 * 
+	 * @param provider the input stream provider. Must not be <code>null</code>.
 	 */
 	public LazyInputStream(InputStreamProvider provider) {
 		if (provider == null)
@@ -135,12 +137,14 @@ public String toString() {
 	}
 
 	/**
-	 * An interface to be implemented by clients that wish to utilize {@link LazyInputStream}s.  
-	 * The implementation of this interface should defer obtaining the desired input stream until absolutely necessary.
+	 * An interface to be implemented by clients that wish to utilize
+	 * {@link LazyInputStream}s. The implementation of this interface should defer
+	 * obtaining the desired input stream until absolutely necessary.
 	 */
 	public static interface InputStreamProvider {
 		/**
 		 * Return the input stream.
+		 * 
 		 * @return the input stream
 		 * @throws IOException thrown if there is an issue obtaining the stream
 		 */
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/ProxyStreamTransformer.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/ProxyStreamTransformer.java
index dfd5b0547ac..b70067b0b14 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/ProxyStreamTransformer.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/ProxyStreamTransformer.java
@@ -21,8 +21,12 @@
 import java.net.URL;
 
 /**
- * A proxy stream transformer is a transformer instance that relies on reflection to obtain the "getInputStream" method from an underlying object.  
- * This class is useful due to the restrictions in the builder that prevent transformer providers from directly implementing {@link StreamTransformer} due to visibility and builder issues related to referring to classes within fragments.
+ * A proxy stream transformer is a transformer instance that relies on
+ * reflection to obtain the "getInputStream" method from an underlying object.
+ * This class is useful due to the restrictions in the builder that prevent
+ * transformer providers from directly implementing {@link StreamTransformer}
+ * due to visibility and builder issues related to referring to classes within
+ * fragments.
  */
 public class ProxyStreamTransformer extends StreamTransformer {
 
@@ -31,13 +35,17 @@ public class ProxyStreamTransformer extends StreamTransformer {
 
 	/**
 	 * Create a new proxy transformer based on the given object.
+	 * 
 	 * @param object the object to proxy
-	 * @throws SecurityException thrown if there is an issue utilizing the reflection methods
-	 * @throws NoSuchMethodException thrown if the provided object does not have a "getInputStream" method that takes an {@link InputStream} and an {@link URL}
+	 * @throws SecurityException     thrown if there is an issue utilizing the
+	 *                               reflection methods
+	 * @throws NoSuchMethodException thrown if the provided object does not have a
+	 *                               "getInputStream" method that takes an
+	 *                               {@link InputStream} and an {@link URL}
 	 */
 	public ProxyStreamTransformer(Object object) throws SecurityException, NoSuchMethodException {
 		this.object = object;
-		method = object.getClass().getMethod("getInputStream", new Class[] {InputStream.class, URL.class}); //$NON-NLS-1$
+		method = object.getClass().getMethod("getInputStream", new Class[] { InputStream.class, URL.class }); //$NON-NLS-1$
 		Class<?> returnType = method.getReturnType();
 		if (!returnType.equals(InputStream.class))
 			throw new NoSuchMethodException();
@@ -47,7 +55,7 @@ public ProxyStreamTransformer(Object object) throws SecurityException, NoSuchMet
 	@Override
 	public InputStream getInputStream(InputStream inputStream, URL transformerUrl) throws IOException {
 		try {
-			return (InputStream) method.invoke(object, new Object[] {inputStream, transformerUrl});
+			return (InputStream) method.invoke(object, new Object[] { inputStream, transformerUrl });
 		} catch (IllegalArgumentException | IllegalAccessException e) {
 			throw new IOException(e.getMessage());
 		} catch (InvocationTargetException e) {
@@ -59,7 +67,8 @@ public InputStream getInputStream(InputStream inputStream, URL transformerUrl) t
 
 	/**
 	 * Get the object that is being proxied.
-	 * @return the object.  Never <code>null</code>.
+	 * 
+	 * @return the object. Never <code>null</code>.
 	 */
 	public Object getTransformer() {
 		return object;
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/StreamTransformer.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/StreamTransformer.java
index 3e64a54102e..f5272554eb6 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/StreamTransformer.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/StreamTransformer.java
@@ -19,15 +19,19 @@
 import java.net.URL;
 
 /**
- * This class represents the fundamental building block of the transformer system.  
- * Implementations of this class are capable of transforming an input stream based on a given transformer url.
- * The meaning and content of this URL are unspecified - it is the transformers responsibility to interpret these as need be.
+ * This class represents the fundamental building block of the transformer
+ * system. Implementations of this class are capable of transforming an input
+ * stream based on a given transformer url. The meaning and content of this URL
+ * are unspecified - it is the transformers responsibility to interpret these as
+ * need be.
  */
 public abstract class StreamTransformer {
 	/**
 	 * Provided a transformed version of the provided input stream.
-	 * @param inputStream the original stream
-	 * @param transformerUrl an url that may be used by the transformer in determining the proper transform to invoke.
+	 * 
+	 * @param inputStream    the original stream
+	 * @param transformerUrl an url that may be used by the transformer in
+	 *                       determining the proper transform to invoke.
 	 * @return the transformed stream
 	 * @throws IOException thrown if there is an issue invoking the transform
 	 */
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformInstanceListData.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformInstanceListData.java
index 25eccfad584..ceae577da35 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformInstanceListData.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformInstanceListData.java
@@ -22,7 +22,8 @@
 import org.osgi.util.tracker.ServiceTracker;
 
 /**
- * Class that represents a dynamic list of TransformTuples that have been registered against a particular transform type.
+ * Class that represents a dynamic list of TransformTuples that have been
+ * registered against a particular transform type.
  */
 public class TransformInstanceListData extends ServiceTracker<URL, URL> {
 	/**
@@ -30,7 +31,8 @@ public class TransformInstanceListData extends ServiceTracker<URL, URL> {
 	 */
 	private static final String[] EMPTY_TYPES = new String[0];
 	/**
-	 * Stale state of the transform list. Set to true whenever one of the ServiceTrackerCustomization methods are invoked.
+	 * Stale state of the transform list. Set to true whenever one of the
+	 * ServiceTrackerCustomization methods are invoked.
 	 */
 	private volatile boolean stale = true;
 
@@ -45,18 +47,23 @@ public class TransformInstanceListData extends ServiceTracker<URL, URL> {
 	private List<TransformTuple> rawTuples = new ArrayList<>();
 
 	/**
-	 * Map from bundle ID -> boolean representing whether or not a given bundle currently has any transforms registered against it.
+	 * Map from bundle ID -> boolean representing whether or not a given bundle
+	 * currently has any transforms registered against it.
 	 */
 	private Map<String, Boolean> bundleIdToTransformPresence = new HashMap<>();
 	private final EquinoxLogServices logServices;
 
 	/**
-	 * Create a new transform list bound to the given context. If new transforms are registered against the given context the contents of this list will change.
-	 * @param context the bundle context
+	 * Create a new transform list bound to the given context. If new transforms are
+	 * registered against the given context the contents of this list will change.
+	 * 
+	 * @param context     the bundle context
 	 * @param logServices
-	 * @throws InvalidSyntaxException thrown if there's an issue listening for changes to the given transformer type
+	 * @throws InvalidSyntaxException thrown if there's an issue listening for
+	 *                                changes to the given transformer type
 	 */
-	public TransformInstanceListData(BundleContext context, EquinoxLogServices logServices) throws InvalidSyntaxException {
+	public TransformInstanceListData(BundleContext context, EquinoxLogServices logServices)
+			throws InvalidSyntaxException {
 		super(context, context.createFilter("(&(objectClass=" //$NON-NLS-1$
 				+ URL.class.getName() + ")(" + TransformTuple.TRANSFORMER_TYPE //$NON-NLS-1$
 				+ "=*))"), null); //$NON-NLS-1$
@@ -65,7 +72,9 @@ public TransformInstanceListData(BundleContext context, EquinoxLogServices logSe
 	}
 
 	/**
-	 * Return the transforms types currently held by this list. If a change has been detected since the last request this list will be rebuilt.
+	 * Return the transforms types currently held by this list. If a change has been
+	 * detected since the last request this list will be rebuilt.
+	 * 
 	 * @return the transforms types currently held by this list
 	 */
 	public synchronized String[] getTransformTypes() {
@@ -78,7 +87,9 @@ public synchronized String[] getTransformTypes() {
 	}
 
 	/**
-	 * Return the transforms of a particular type currently held by this list. If a change has been detected since the last request this list will be rebuilt.
+	 * Return the transforms of a particular type currently held by this list. If a
+	 * change has been detected since the last request this list will be rebuilt.
+	 * 
 	 * @return the transforms currently held by this list
 	 */
 	public synchronized TransformTuple[] getTransformsFor(String type) {
@@ -89,7 +100,10 @@ public synchronized TransformTuple[] getTransformsFor(String type) {
 	}
 
 	/**
-	 * Return whether or not there are any transforms who's bundle pattern matches the ID of the provided bundle. Only transforms with a present transform handler are considered during the invocation of this method.
+	 * Return whether or not there are any transforms who's bundle pattern matches
+	 * the ID of the provided bundle. Only transforms with a present transform
+	 * handler are considered during the invocation of this method.
+	 * 
 	 * @param bundle the bundle to test
 	 * @return the presence of associated transforms.
 	 */
@@ -115,7 +129,8 @@ public synchronized boolean hasTransformsFor(Bundle bundle) {
 	}
 
 	/**
-	 * Consults the bundle context for services of the transformer type type and builds the internal cache.
+	 * Consults the bundle context for services of the transformer type type and
+	 * builds the internal cache.
 	 */
 	private void rebuildTransformMap() {
 		transformerToTuple.clear();
@@ -167,4 +182,4 @@ public void removedService(ServiceReference<URL> reference, URL service) {
 		super.removedService(reference, service);
 		stale = true;
 	}
-}
\ No newline at end of file
+}
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformTuple.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformTuple.java
index 9b400167e0b..674d67f2782 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformTuple.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformTuple.java
@@ -18,15 +18,18 @@
 import java.util.regex.Pattern;
 
 /**
- * Class that represents an association between a bundle pattern, a path pattern, and the location of a transformer to apply to any resource that matches both the bundle and path pattern.
+ * Class that represents an association between a bundle pattern, a path
+ * pattern, and the location of a transformer to apply to any resource that
+ * matches both the bundle and path pattern.
  */
 public class TransformTuple {
 
 	/**
-	 * Constant used when registering transform tuples to identify the type of transformer they should be assigned to.
+	 * Constant used when registering transform tuples to identify the type of
+	 * transformer they should be assigned to.
 	 */
 	public static final String TRANSFORMER_TYPE = "equinox.transformerType"; //$NON-NLS-1$
 	public Pattern bundlePattern;
 	public Pattern pathPattern;
 	public URL transformerUrl;
-}
\ No newline at end of file
+}
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformedBundleEntry.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformedBundleEntry.java
index e5495e6cb36..6e511a9420e 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformedBundleEntry.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformedBundleEntry.java
@@ -22,7 +22,8 @@
 import org.eclipse.osgi.storage.bundlefile.BundleEntry;
 
 /**
- * This class is capable of providing a transformed version of an entry contained within a base bundle entity.
+ * This class is capable of providing a transformed version of an entry
+ * contained within a base bundle entity.
  */
 public class TransformedBundleEntry extends BundleEntry {
 
@@ -32,9 +33,11 @@ public class TransformedBundleEntry extends BundleEntry {
 	private TransformedBundleFile bundleFile;
 
 	/**
-	 * Create a wrapped bundle entry.  Calls to obtain the content of this entry will be resolved via the provided input stream rather than the original. 
-	 * @param bundleFile the host bundle file
-	 * @param original the original entry
+	 * Create a wrapped bundle entry. Calls to obtain the content of this entry will
+	 * be resolved via the provided input stream rather than the original.
+	 * 
+	 * @param bundleFile    the host bundle file
+	 * @param original      the original entry
 	 * @param wrappedStream the override stream
 	 */
 	public TransformedBundleEntry(TransformedBundleFile bundleFile, BundleEntry original, InputStream wrappedStream) {
@@ -69,8 +72,9 @@ public String getName() {
 	}
 
 	/**
-	 * Obtaining the size means inspecting the transformed stream.  
-	 * If this stream does not support marks the stream is drained and a copy is retained for later use.
+	 * Obtaining the size means inspecting the transformed stream. If this stream
+	 * does not support marks the stream is drained and a copy is retained for later
+	 * use.
 	 */
 	public long getSize() {
 		ByteArrayOutputStream tempBuffer = new ByteArrayOutputStream(1024);
@@ -90,8 +94,11 @@ public long getSize() {
 				stream = new ByteArrayInputStream(tempBuffer.toByteArray());
 			}
 		} catch (IOException e) {
-			bundleFile.getGeneration().getBundleInfo().getStorage().getLogServices().log(EquinoxContainer.NAME, FrameworkLogEntry.ERROR, "Problem calculating size of stream for file.  Stream may now be corrupted : " //$NON-NLS-1$
-					+ getName(), e);
+			bundleFile.getGeneration().getBundleInfo().getStorage().getLogServices().log(EquinoxContainer.NAME,
+					FrameworkLogEntry.ERROR,
+					"Problem calculating size of stream for file.  Stream may now be corrupted : " //$NON-NLS-1$
+							+ getName(),
+					e);
 		}
 		return tempBuffer.size();
 
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformedBundleFile.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformedBundleFile.java
index 9bf4fe8a873..4839e2c5200 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformedBundleFile.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformedBundleFile.java
@@ -28,8 +28,10 @@
 import org.osgi.framework.Bundle;
 
 /**
- * This class is capable of providing transformed versions of entries contained within a base bundle file.
- * For requests that transform bundle contents into local resources (such as file URLs) the transformed state of the bundle is written to the configuration area.
+ * This class is capable of providing transformed versions of entries contained
+ * within a base bundle file. For requests that transform bundle contents into
+ * local resources (such as file URLs) the transformed state of the bundle is
+ * written to the configuration area.
  */
 public class TransformedBundleFile extends BundleFileWrapper {
 
@@ -39,11 +41,13 @@ public class TransformedBundleFile extends BundleFileWrapper {
 	private final Debug debug;
 
 	/**
-	 * Create a wrapped bundle file.  
-	 * Requests into this file will be compared to the list of known transformers and transformer templates and if there's a match the transformed entity is returned instead of the original.
+	 * Create a wrapped bundle file. Requests into this file will be compared to the
+	 * list of known transformers and transformer templates and if there's a match
+	 * the transformed entity is returned instead of the original.
+	 * 
 	 * @param transformerHook the transformer hook
-	 * @param data the original data
-	 * @param delegate the original file
+	 * @param data            the original data
+	 * @param delegate        the original file
 	 */
 	public TransformedBundleFile(TransformerHook transformerHook, Generation generation, BundleFile delegate) {
 		super(delegate);
@@ -81,13 +85,11 @@ public InputStream getInputStream() throws IOException {
 	}
 
 	/**
-	 * Return the input stream that results from applying the given transformer
-	 * URL to the provided input stream.
+	 * Return the input stream that results from applying the given transformer URL
+	 * to the provided input stream.
 	 * 
-	 * @param inputStream
-	 *            the stream to transform
-	 * @param bundle
-	 *            the resource representing the transformer
+	 * @param inputStream the stream to transform
+	 * @param bundle      the resource representing the transformer
 	 * @return the transformed stream
 	 */
 	protected InputStream getInputStream(InputStream inputStream, Bundle bundle, String path) {
@@ -108,8 +110,10 @@ protected InputStream getInputStream(InputStream inputStream, Bundle bundle, Str
 					try {
 						return transformer.getInputStream(inputStream, transformTuple.transformerUrl);
 					} catch (IOException e) {
-						generation.getBundleInfo().getStorage().getLogServices().log(EquinoxContainer.NAME, FrameworkLogEntry.ERROR, "Problem obtaining transformed stream from transformer : " //$NON-NLS-1$
-								+ transformer.getClass().getName(), e);
+						generation.getBundleInfo().getStorage().getLogServices().log(EquinoxContainer.NAME,
+								FrameworkLogEntry.ERROR, "Problem obtaining transformed stream from transformer : " //$NON-NLS-1$
+										+ transformer.getClass().getName(),
+								e);
 
 					}
 				}
@@ -132,8 +136,8 @@ private boolean match(Pattern pattern, String string) {
 	}
 
 	/**
-	 * This file is a copy of {@link ZipBundleFile#getFile(String, boolean)}
-	 * with modifications.
+	 * This file is a copy of {@link ZipBundleFile#getFile(String, boolean)} with
+	 * modifications.
 	 */
 	public File getFile(String path, boolean nativeCode) {
 		File originalFile = delegate.getFile(path, nativeCode);
@@ -190,12 +194,12 @@ public File getFile(String path, boolean nativeCode) {
 	}
 
 	/**
-	 * Answers whether the resource at the given path or any of its children has
-	 * a transform associated with it.
+	 * Answers whether the resource at the given path or any of its children has a
+	 * transform associated with it.
 	 * 
 	 * @param path
-	 * @return whether the resource at the given path or any of its children has
-	 * a transform associated with it.
+	 * @return whether the resource at the given path or any of its children has a
+	 *         transform associated with it.
 	 */
 	private boolean hasTransforms(String path) {
 		if (!transformerHook.hasTransformers())
@@ -206,13 +210,12 @@ private boolean hasTransforms(String path) {
 	/**
 	 * Extracts a directory and all sub content to disk
 	 * 
-	 * @param dirName
-	 *            the directory name to extract
-	 * @return the File used to extract the content to. A value of
-	 *         <code>null</code> is returned if the directory to extract does
-	 *         not exist or if content extraction is not supported.
+	 * @param dirName the directory name to extract
+	 * @return the File used to extract the content to. A value of <code>null</code>
+	 *         is returned if the directory to extract does not exist or if content
+	 *         extraction is not supported.
 	 * 
-	 * This method is derived from ZipBundleFile#extractDirectory(String).
+	 *         This method is derived from ZipBundleFile#extractDirectory(String).
 	 */
 	protected synchronized File extractDirectory(String dirName) {
 		Enumeration<String> entries = delegate.getEntryPaths(dirName);
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformerHook.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformerHook.java
index 413e6e1a580..1eecc150be6 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformerHook.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformerHook.java
@@ -23,9 +23,11 @@
 import org.osgi.framework.*;
 
 /**
- * The framework extension that is capable of applying transforms to bundle content.
+ * The framework extension that is capable of applying transforms to bundle
+ * content.
  */
-public class TransformerHook implements BundleFileWrapperFactoryHook, HookConfigurator, ActivatorHookFactory, BundleActivator {
+public class TransformerHook
+		implements BundleFileWrapperFactoryHook, HookConfigurator, ActivatorHookFactory, BundleActivator {
 	private volatile TransformerList transformers;
 	private volatile TransformInstanceListData templates;
 	private EquinoxLogServices logServices;
diff --git a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformerList.java b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformerList.java
index 701f3b3a9fd..37e5d30c2f7 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformerList.java
+++ b/bundles/org.eclipse.equinox.transforms.hook/src/org/eclipse/equinox/internal/transforms/TransformerList.java
@@ -27,7 +27,8 @@
 public class TransformerList extends ServiceTracker<Object, Object> {
 
 	/**
-	 * The stale state of this list.  Set to true every time a new matching service instance is detected.
+	 * The stale state of this list. Set to true every time a new matching service
+	 * instance is detected.
 	 */
 	private volatile boolean stale = true;
 
@@ -39,8 +40,10 @@ public class TransformerList extends ServiceTracker<Object, Object> {
 
 	/**
 	 * Create a new instance of this list.
+	 * 
 	 * @param context the context to track
-	 * @throws InvalidSyntaxException thrown if there's an issue listening for changes to the given transformer type
+	 * @throws InvalidSyntaxException thrown if there's an issue listening for
+	 *                                changes to the given transformer type
 	 */
 	public TransformerList(BundleContext context, EquinoxLogServices logServices) throws InvalidSyntaxException {
 		super(context, context.createFilter("(&(objectClass=" //$NON-NLS-1$
@@ -51,10 +54,12 @@ public TransformerList(BundleContext context, EquinoxLogServices logServices) th
 	}
 
 	/**
-	 * Return the transformer of the given type being monitored by this list.
-	 * If the list is stale it will first be rebuilt.
+	 * Return the transformer of the given type being monitored by this list. If the
+	 * list is stale it will first be rebuilt.
+	 * 
 	 * @param type the type of transformer
-	 * @return the transformer or null if no transformer of the given type is available.
+	 * @return the transformer or null if no transformer of the given type is
+	 *         available.
 	 */
 	public synchronized StreamTransformer getTransformer(String type) {
 		if (stale) {
@@ -71,7 +76,8 @@ public synchronized boolean hasTransformers() {
 	}
 
 	/**
-	 * Consults the bundle context for services of the transformer type and builds the internal cache.
+	 * Consults the bundle context for services of the transformer type and builds
+	 * the internal cache.
 	 */
 	private void rebuildTransformersMap() {
 		transformers.clear();
diff --git a/bundles/org.eclipse.equinox.transforms.hook/transformsHook.properties b/bundles/org.eclipse.equinox.transforms.hook/transformsHook.properties
index 4a05382081c..4dc4895d738 100644
--- a/bundles/org.eclipse.equinox.transforms.hook/transformsHook.properties
+++ b/bundles/org.eclipse.equinox.transforms.hook/transformsHook.properties
@@ -12,4 +12,4 @@
 #     IBM Corporation - initial API and implementation
 ###############################################################################
 bundleName=Transformer Hook Framework Extension
-providerName=Eclipse.org - Equinox
\ No newline at end of file
+providerName=Eclipse.org - Equinox