}
@Override
- public String loadPlugin(Path pluginPath) throws PluginException {
+ public String loadPlugin(Path pluginPath) {
if ((pluginPath == null) || Files.notExists(pluginPath)) {
throw new IllegalArgumentException(String.format("Specified plugin %s does not exist!", pluginPath));
}
for (Path pluginPath : pluginPaths) {
try {
loadPluginFromPath(pluginPath);
- } catch (PluginException e) {
+ } catch (PluginRuntimeException e) {
log.error(e.getMessage(), e);
}
}
// resolve plugins
try {
resolvePlugins();
- } catch (PluginException e) {
+ } catch (PluginRuntimeException e) {
log.error(e.getMessage(), e);
}
}
* Unload the specified plugin and it's dependents.
*/
@Override
- public boolean unloadPlugin(String pluginId) throws PluginException {
+ public boolean unloadPlugin(String pluginId) {
return unloadPlugin(pluginId, true);
}
- private boolean unloadPlugin(String pluginId, boolean unloadDependents) throws PluginException {
+ private boolean unloadPlugin(String pluginId, boolean unloadDependents) {
try {
if (unloadDependents) {
List<String> dependents = dependencyResolver.getDependents(pluginId);
try {
((Closeable) classLoader).close();
} catch (IOException e) {
- throw new PluginException("Cannot close classloader", e);
+ throw new PluginRuntimeException(e, "Cannot close classloader");
}
}
}
}
@Override
- public boolean deletePlugin(String pluginId) throws PluginException {
+ public boolean deletePlugin(String pluginId) {
checkPluginId(pluginId);
PluginWrapper pluginWrapper = getPlugin(pluginId);
* Start the specified plugin and its dependencies.
*/
@Override
- public PluginState startPlugin(String pluginId) throws PluginException {
+ public PluginState startPlugin(String pluginId) {
checkPluginId(pluginId);
PluginWrapper pluginWrapper = getPlugin(pluginId);
itr.remove();
firePluginStateEvent(new PluginStateEvent(this, pluginWrapper, pluginState));
- } catch (PluginException e) {
+ } catch (PluginRuntimeException e) {
log.error(e.getMessage(), e);
}
}
* Stop the specified plugin and it's dependents.
*/
@Override
- public PluginState stopPlugin(String pluginId) throws PluginException {
+ public PluginState stopPlugin(String pluginId) {
return stopPlugin(pluginId, true);
}
- private PluginState stopPlugin(String pluginId, boolean stopDependents) throws PluginException {
+ private PluginState stopPlugin(String pluginId, boolean stopDependents) {
checkPluginId(pluginId);
PluginWrapper pluginWrapper = getPlugin(pluginId);
}
@Override
- public boolean disablePlugin(String pluginId) throws PluginException {
+ public boolean disablePlugin(String pluginId) {
checkPluginId(pluginId);
PluginWrapper pluginWrapper = getPlugin(pluginId);
}
@Override
- public boolean enablePlugin(String pluginId) throws PluginException {
+ public boolean enablePlugin(String pluginId) {
checkPluginId(pluginId);
PluginWrapper pluginWrapper = getPlugin(pluginId);
for (ExtensionWrapper extensionWrapper : extensionsWrapper) {
try {
extensions.add(extensionWrapper.getExtension());
- } catch (PluginException e) {
+ } catch (PluginRuntimeException e) {
log.error("Cannot retrieve extension", e);
}
}
return pluginStatusProvider.isPluginDisabled(pluginId);
}
- protected void resolvePlugins() throws PluginException {
+ protected void resolvePlugins() {
// retrieves the plugins descriptors
List<PluginDescriptor> descriptors = new ArrayList<>();
for (PluginWrapper plugin : plugins.values()) {
}
}
- protected PluginWrapper loadPluginFromPath(Path pluginPath) throws PluginException {
+ protected PluginWrapper loadPluginFromPath(Path pluginPath) {
// Test for plugin path duplication
String pluginId = idForPath(pluginPath);
if (pluginId != null) {
pluginId = pluginDescriptor.getPluginId();
if (plugins.containsKey(pluginId)) {
PluginWrapper loadedPlugin = getPlugin(pluginId);
- throw new PluginException("There is an already loaded plugin ({}) "
+ throw new PluginRuntimeException("There is an already loaded plugin ({}) "
+ "with the same id ({}) as the plugin at path '{}'. Simultaneous loading "
+ "of plugins with the same PluginId is not currently supported.\n"
+ "As a workaround you may include PluginVersion and PluginProvider "
* Override this to change the validation criteria.
*
* @param descriptor the plugin descriptor to validate
- * @throws PluginException if validation fails
+ * @throws PluginRuntimeException if validation fails
*/
- protected void validatePluginDescriptor(PluginDescriptor descriptor) throws PluginException {
+ protected void validatePluginDescriptor(PluginDescriptor descriptor) {
if (StringUtils.isNullOrEmpty(descriptor.getPluginId())) {
- throw new PluginException("Field 'id' cannot be empty");
+ throw new PluginRuntimeException("Field 'id' cannot be empty");
}
if (descriptor.getVersion() == null) {
- throw new PluginException("Field 'version' cannot be empty");
+ throw new PluginRuntimeException("Field 'version' cannot be empty");
}
}
for (ExtensionWrapper<T> extensionWrapper : extensionsWrapper) {
try {
extensions.add(extensionWrapper.getExtension());
- } catch (PluginException e) {
+ } catch (PluginRuntimeException e) {
log.error("Cannot retrieve extension", e);
}
}
}
@Override
- public boolean deletePluginPath(Path pluginPath) throws PluginException {
+ public boolean deletePluginPath(Path pluginPath) {
if (!filter.accept(pluginPath.toFile())) {
return false;
}
} catch (NoSuchFileException e) {
return false; // Return false on not found to be compatible with previous API (#135)
} catch (IOException e) {
- throw new PluginException(e);
+ throw new PluginRuntimeException(e);
}
}
}
@Override
- public PluginDescriptor find(Path pluginPath) throws PluginException {
+ public PluginDescriptor find(Path pluginPath) {
for (PluginDescriptorFinder finder : finders) {
if (finder.isApplicable(pluginPath)) {
log.debug("'{}' is applicable for plugin '{}'", finder, pluginPath);
}
}
- throw new PluginException("No PluginDescriptorFinder for plugin '{}'", pluginPath);
+ throw new PluginRuntimeException("No PluginDescriptorFinder for plugin '{}'", pluginPath);
}
}
}
@Override
- public boolean deletePluginPath(Path pluginPath) throws PluginException {
+ public boolean deletePluginPath(Path pluginPath) {
for (PluginRepository repository : repositories) {
if (repository.deletePluginPath(pluginPath)) {
return true;
* Creates an extension instance.
*/
@Override
- public <T> T create(Class<T> extensionClass) throws PluginException {
+ public <T> T create(Class<T> extensionClass) {
log.debug("Create instance for extension '{}'", extensionClass.getName());
try {
return extensionClass.newInstance();
} catch (Exception e) {
- throw new PluginException(e);
+ throw new PluginRuntimeException(e);
}
}
}
/**
- * Load a plugin from disk. If the path is a zip file, first unpack
+ * Load a plugin from disk. If the path is a zip file, first unpack.
+ *
* @param pluginPath plugin location on disk
* @return PluginWrapper for the loaded plugin or null if not loaded
- * @throws PluginException if problems during load
+ * @throws PluginRuntimeException if problems during load
*/
@Override
- protected PluginWrapper loadPluginFromPath(Path pluginPath) throws PluginException {
+ protected PluginWrapper loadPluginFromPath(Path pluginPath) {
// First unzip any ZIP files
try {
pluginPath = FileUtils.expandIfZip(pluginPath);
import org.pf4j.util.ZipFileFilter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-import org.pf4j.util.NameFileFilter;
import java.io.File;
import java.io.FileFilter;
}
@Override
- public boolean deletePluginPath(Path pluginPath) throws PluginException {
+ public boolean deletePluginPath(Path pluginPath) {
FileUtils.optimisticDelete(FileUtils.findWithEnding(pluginPath, ".zip", ".ZIP", ".Zip"));
return super.deletePluginPath(pluginPath);
}
}
@Override
- public void disablePlugin(String pluginId) throws PluginException {
+ public void disablePlugin(String pluginId) {
disabledPlugins.add(pluginId);
try {
FileUtils.writeLines(disabledPlugins, pluginsRoot.resolve("disabled.txt").toFile());
} catch (IOException e) {
- throw new PluginException(e);
+ throw new PluginRuntimeException(e);
}
}
@Override
- public void enablePlugin(String pluginId) throws PluginException {
+ public void enablePlugin(String pluginId) {
disabledPlugins.remove(pluginId);
try {
FileUtils.writeLines(disabledPlugins, pluginsRoot.resolve("disabled.txt").toFile());
} catch (IOException e) {
- throw new PluginException(e);
+ throw new PluginRuntimeException(e);
}
}
/**
* It will be thrown if a cyclic dependency is detected.
*/
- public static class CyclicDependencyException extends PluginException {
+ public static class CyclicDependencyException extends PluginRuntimeException {
public CyclicDependencyException() {
super("Cyclic dependencies");
/**
* Indicates that the dependencies required were not found.
*/
- public static class DependenciesNotFoundException extends PluginException {
+ public static class DependenciesNotFoundException extends PluginRuntimeException {
private List<String> dependencies;
/**
* Indicates that some dependencies have wrong version.
*/
- public static class DependenciesWrongVersionException extends PluginException {
+ public static class DependenciesWrongVersionException extends PluginRuntimeException {
private List<WrongDependencyVersion> dependencies;
*/
public interface ExtensionFactory {
- <T> T create(Class<T> extensionClass) throws PluginException;
+ <T> T create(Class<T> extensionClass);
}
}
@SuppressWarnings("unchecked")
- public T getExtension() throws PluginException {
+ public T getExtension() {
if (extension == null) {
extension = (T) extensionFactory.create(descriptor.extensionClass);
}
}
@Override
- public PluginDescriptor find(Path pluginPath) throws PluginException {
+ public PluginDescriptor find(Path pluginPath) {
Manifest manifest = readManifest(pluginPath);
return createPluginDescriptor(manifest);
}
- protected Manifest readManifest(Path pluginPath) throws PluginException {
+ protected Manifest readManifest(Path pluginPath) {
if (FileUtils.isJarFile(pluginPath)) {
try (JarFile jar = new JarFile(pluginPath.toFile())) {
Manifest manifest = jar.getManifest();
return manifest;
}
} catch (IOException e) {
- throw new PluginException(e);
+ throw new PluginRuntimeException(e);
}
}
Path manifestPath = getManifestPath(pluginPath);
if (manifestPath == null) {
- throw new PluginException("Cannot find the manifest path");
+ throw new PluginRuntimeException("Cannot find the manifest path");
}
log.debug("Lookup plugin descriptor in '{}'", manifestPath);
if (Files.notExists(manifestPath)) {
- throw new PluginException("Cannot find '{}' path", manifestPath);
+ throw new PluginRuntimeException("Cannot find '{}' path", manifestPath);
}
try (InputStream input = Files.newInputStream(manifestPath)) {
return new Manifest(input);
} catch (IOException e) {
- throw new PluginException(e);
+ throw new PluginRuntimeException(e);
}
}
* This method is called by the application when the plugin is started.
* See {@link PluginManager#startPlugin(String)}.
*/
- public void start() throws PluginException {
+ public void start() {
}
/**
* This method is called by the application when the plugin is stopped.
* See {@link PluginManager#stopPlugin(String)}.
*/
- public void stop() throws PluginException {
+ public void stop() {
}
/**
* This method is called by the application when the plugin is deleted.
* See {@link PluginManager#deletePlugin(String)}.
*/
- public void delete() throws PluginException {
+ public void delete() {
}
}
/**
* @author Decebal Suiu
*/
-public class PluginAlreadyLoadedException extends PluginException {
+public class PluginAlreadyLoadedException extends PluginRuntimeException {
private final String pluginId;
private final Path pluginPath;
/**
* Returns true if this finder is applicable to the given {@link Path}.
- *
- * @param pluginPath
- * @return
*/
boolean isApplicable(Path pluginPath);
- PluginDescriptor find(Path pluginPath) throws PluginException;
+ PluginDescriptor find(Path pluginPath);
}
+++ /dev/null
-/*
- * Copyright (C) 2012-present the original author or authors.
- *
- * 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 org.pf4j;
-
-import org.pf4j.util.StringUtils;
-
-/**
- * An exception used to indicate that a plugin problem occurred.
- * It's a generic plugin exception class to be thrown when no more specific class is applicable.
- *
- * @author Decebal Suiu
- */
-public class PluginException extends Exception {
-
- public PluginException() {
- super();
- }
-
- public PluginException(String message) {
- super(message);
- }
-
- public PluginException(Throwable cause) {
- super(cause);
- }
-
- public PluginException(String message, Throwable cause) {
- super(message, cause);
- }
-
- public PluginException(Throwable cause, String message, Object... args) {
- super(StringUtils.format(message, args), cause);
- }
-
- public PluginException(String message, Object... args) {
- super(StringUtils.format(message, args));
- }
-
-}
* Load a plugin.
*
* @param pluginPath the plugin location
- * @return the pluginId of the installed plugin as specified in
- * its {@linkplain PluginDescriptor metadata}
- * @throws PluginException if load of plugin fails
+ * @return the pluginId of the installed plugin as specified in its {@linkplain PluginDescriptor metadata}
+ * @throws PluginRuntimeException if something goes wrong
*/
- String loadPlugin(Path pluginPath) throws PluginException;
+ String loadPlugin(Path pluginPath);
/**
* Start all active plugins.
* Start the specified plugin and its dependencies.
*
* @return the plugin state
+ * @throws PluginRuntimeException if something goes wrong
*/
- PluginState startPlugin(String pluginId) throws PluginException;
+ PluginState startPlugin(String pluginId);
/**
* Stop all active plugins.
* Stop the specified plugin and its dependencies.
*
* @return the plugin state
+ * @throws PluginRuntimeException if something goes wrong
*/
- PluginState stopPlugin(String pluginId) throws PluginException;
+ PluginState stopPlugin(String pluginId);
/**
* Unload a plugin.
*
* @param pluginId the unique plugin identifier, specified in its metadata
* @return true if the plugin was unloaded
+ * @throws PluginRuntimeException if something goes wrong
*/
- boolean unloadPlugin(String pluginId) throws PluginException;
+ boolean unloadPlugin(String pluginId);
/**
* Disables a plugin from being loaded.
*
* @param pluginId the unique plugin identifier, specified in its metadata
* @return true if plugin is disabled
+ * @throws PluginRuntimeException if something goes wrong
*/
- boolean disablePlugin(String pluginId) throws PluginException;
+ boolean disablePlugin(String pluginId);
/**
* Enables a plugin that has previously been disabled.
*
* @param pluginId the unique plugin identifier, specified in its metadata
* @return true if plugin is enabled
+ * @throws PluginRuntimeException if something goes wrong
*/
- boolean enablePlugin(String pluginId) throws PluginException;
+ boolean enablePlugin(String pluginId);
/**
* Deletes a plugin.
*
* @param pluginId the unique plugin identifier, specified in its metadata
* @return true if the plugin was deleted
+ * @throws PluginRuntimeException if something goes wrong
*/
- boolean deletePlugin(String pluginId) throws PluginException;
+ boolean deletePlugin(String pluginId);
ClassLoader getPluginClassLoader(String pluginId);
String getSystemVersion();
/**
- * Gets the path of the folder where plugins are installed
+ * Gets the path of the folder where plugins are installed.
+ *
* @return Path of plugins root
*/
Path getPluginsRoot();
*
* @param pluginPath the plugin path
* @return true if deleted
+ * @throws PluginRuntimeException if something goes wrong
*/
- boolean deletePluginPath(Path pluginPath) throws PluginException;
+ boolean deletePluginPath(Path pluginPath);
}
--- /dev/null
+/*
+ * Copyright (C) 2012-present the original author or authors.
+ *
+ * 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 org.pf4j;
+
+import org.pf4j.util.StringUtils;
+
+/**
+ * An exception used to indicate that a plugin problem occurred.
+ * It's a generic plugin exception class to be thrown when no more specific class is applicable.
+ *
+ * @author Decebal Suiu
+ */
+public class PluginRuntimeException extends RuntimeException {
+
+ public PluginRuntimeException() {
+ super();
+ }
+
+ public PluginRuntimeException(String message) {
+ super(message);
+ }
+
+ public PluginRuntimeException(Throwable cause) {
+ super(cause);
+ }
+
+ public PluginRuntimeException(Throwable cause, String message, Object... args) {
+ super(StringUtils.format(message, args), cause);
+ }
+
+ public PluginRuntimeException(String message, Object... args) {
+ super(StringUtils.format(message, args));
+ }
+
+}
* Disables a plugin from being loaded.
*
* @param pluginId the unique plugin identifier, specified in its metadata
+ * @throws PluginRuntimeException if something goes wrong
*/
- void disablePlugin(String pluginId) throws PluginException;
+ void disablePlugin(String pluginId);
/**
* Enables a plugin that has previously been disabled.
*
* @param pluginId the unique plugin identifier, specified in its metadata
+ * @throws PluginRuntimeException if something goes wrong
*/
- void enablePlugin(String pluginId) throws PluginException;
+ void enablePlugin(String pluginId);
}
}
@Override
- public PluginDescriptor find(Path pluginPath) throws PluginException {
+ public PluginDescriptor find(Path pluginPath) {
Properties properties = readProperties(pluginPath);
return createPluginDescriptor(properties);
}
- protected Properties readProperties(Path pluginPath) throws PluginException {
+ protected Properties readProperties(Path pluginPath) {
Path propertiesPath = getPropertiesPath(pluginPath, propertiesFileName);
if (propertiesPath == null) {
- throw new PluginException("Cannot find the properties path");
+ throw new PluginRuntimeException("Cannot find the properties path");
}
log.debug("Lookup plugin descriptor in '{}'", propertiesPath);
if (Files.notExists(propertiesPath)) {
- throw new PluginException("Cannot find '{}' path", propertiesPath);
+ throw new PluginRuntimeException("Cannot find '{}' path", propertiesPath);
}
Properties properties = new Properties();
try (InputStream input = Files.newInputStream(propertiesPath)) {
properties.load(input);
} catch (IOException e) {
- throw new PluginException(e);
+ throw new PluginRuntimeException(e);
}
return properties;
}
- protected Path getPropertiesPath(Path pluginPath, String propertiesFileName) throws PluginException {
+ protected Path getPropertiesPath(Path pluginPath, String propertiesFileName) {
if (Files.isDirectory(pluginPath)) {
return pluginPath.resolve(Paths.get(propertiesFileName));
} else {
try {
return FileUtils.getPath(pluginPath, propertiesFileName);
} catch (IOException e) {
- throw new PluginException(e);
+ throw new PluginRuntimeException(e);
}
}
}
@Override
@SuppressWarnings("unchecked")
- public <T> T create(Class<T> extensionClass) throws PluginException {
+ public <T> T create(Class<T> extensionClass) {
String extensionClassName = extensionClass.getName();
if (cache.containsKey(extensionClassName)) {
return (T) cache.get(extensionClassName);
@Test
public void testNotFound() {
PluginDescriptorFinder descriptorFinder = new CompoundPluginDescriptorFinder();
- assertThrows(PluginException.class, () -> descriptorFinder.find(pluginsPath.resolve("test-plugin-3")));
+ assertThrows(PluginRuntimeException.class, () -> descriptorFinder.find(pluginsPath.resolve("test-plugin-3")));
}
@Test
* Test of create method, of class DefaultExtensionFactory.
*/
@Test
- public void testCreate() throws PluginException {
+ public void testCreate() {
assertNotNull(extensionFactory.create(TestExtension.class));
}
*/
@Test
public void testCreateFailConstructor() {
- assertThrows(PluginException.class, () -> extensionFactory.create(FailTestExtension.class));
+ assertThrows(PluginRuntimeException.class, () -> extensionFactory.create(FailTestExtension.class));
}
}
}
@Test
- public void validateOK() throws PluginException {
+ public void validateOK() {
pluginManager.validatePluginDescriptor(pluginDescriptor);
}
@Test
public void validateFailsOnId() {
pluginDescriptor.setPluginId("");
- assertThrows(PluginException.class, () -> pluginManager.validatePluginDescriptor(pluginDescriptor));
+ assertThrows(PluginRuntimeException.class, () -> pluginManager.validatePluginDescriptor(pluginDescriptor));
}
@Test
public void validateFailsOnVersion() {
pluginDescriptor.setPluginVersion(null);
- assertThrows(PluginException.class, () -> pluginManager.validatePluginDescriptor(pluginDescriptor));
+ assertThrows(PluginRuntimeException.class, () -> pluginManager.validatePluginDescriptor(pluginDescriptor));
}
@Test
- public void validateNoPluginClass() throws PluginException {
+ public void validateNoPluginClass() {
pluginManager.validatePluginDescriptor(pluginDescriptor);
assertEquals(Plugin.class.getName(), pluginDescriptor.getPluginClass());
}
* Test of {@link DefaultPluginRepository#deletePluginPath(Path)} method.
*/
@Test
- public void testDeletePluginPath() throws PluginException {
+ public void testDeletePluginPath() {
PluginRepository repository = new DefaultPluginRepository(pluginsPath);
assertTrue(Files.exists(pluginsPath.resolve("plugin-1.zip")));
// Verify the second plugin is not loaded as it has the same metadata
pluginManager.loadPluginFromPath(plugin2.path());
fail("Expected loadPluginFromPath to fail");
- } catch (PluginException e) {
+ } catch (PluginRuntimeException e) {
// Check the path of the loaded plugin remains the same
PluginWrapper loadedPlugin = pluginManager.getPlugin(pluginId);
assertThat(loadedPlugin.getPluginPath(), equalTo(loadedPlugin1Path));
// Verify the second plugin is not loaded as it has the same pluginId
pluginManager.loadPluginFromPath(plugin2.path());
fail("Expected loadPluginFromPath to fail");
- } catch (PluginException e) {
+ } catch (PluginRuntimeException e) {
// Check the path and version of the loaded plugin remain the same
PluginWrapper loadedPlugin = pluginManager.getPlugin(pluginId);
assertThat(loadedPlugin.getPluginPath(), equalTo(loadedPlugin1Path));
@Test
public void testFindNotFound() {
PluginDescriptorFinder descriptorFinder = new ManifestPluginDescriptorFinder();
- assertThrows(PluginException.class, () -> descriptorFinder.find(pluginsPath.resolve("test-plugin-3")));
+ assertThrows(PluginRuntimeException.class, () -> descriptorFinder.find(pluginsPath.resolve("test-plugin-3")));
}
private Manifest getPlugin1Manifest() {
@Test
public void testNotFound() {
PluginDescriptorFinder descriptorFinder = new PropertiesPluginDescriptorFinder();
- assertThrows(PluginException.class, () -> descriptorFinder.find(pluginsPath.resolve("test-plugin-3")));
+ assertThrows(PluginRuntimeException.class, () -> descriptorFinder.find(pluginsPath.resolve("test-plugin-3")));
}
private Properties getPlugin1Properties() {
public class SingletonExtensionFactoryTest {
@Test
- public void create() throws PluginException {
+ public void create() {
ExtensionFactory extensionFactory = new SingletonExtensionFactory();
Object extensionOne = extensionFactory.create(TestExtension.class);
Object extensionTwo = extensionFactory.create(TestExtension.class);
}
@Test
- public void createNewEachTime() throws PluginException {
+ public void createNewEachTime() {
ExtensionFactory extensionFactory = new SingletonExtensionFactory(FailTestExtension.class.getName());
Object extensionOne = extensionFactory.create(TestExtension.class);
Object extensionTwo = extensionFactory.create(TestExtension.class);
projects / pf4j.git / commitdiff