add RuntimeMode with DEVELOPMENT and DEPLOYMENT values and working on DEVELOPMENT mode

README.md

@@ -61,8 +61,8 @@ It's very simple to add pf4j in your application:
 
 In above code, I created a **DefaultPluginManager** (it's the default implementation for
 **PluginManager** interface) that loads and starts all active(resolved) plugins.  
-Each available plugin is loaded using a **PluginClassLoader**.   
+Each available plugin is loaded using a different java class loader, **PluginClassLoader**.   
-The **PluginClassLoader** contains only classes found in _classes_ and _lib_ folders of plugin and runtime classes and libraries of the required plugins. 
+The **PluginClassLoader** contains only classes found in **PluginClasspath** (default _classes_ and _lib_ folders) of plugin and runtime classes and libraries of the required/dependent plugins. 
 The plugins are stored in a folder. You can specify the plugins folder in the constructor of DefaultPluginManager. If the plugins folder is not specified 
 than the location is returned by `System.getProperty("pf4j.pluginsDir", "plugins")`.
 
@@ -71,12 +71,12 @@ The structure of plugins folder is:
 * plugin2.zip (or plugin2 folder)
 
 In plugins folder you can put a plugin as folder or archive file (zip).
-A plugin folder has this structure:
+A plugin folder has this structure by default:
 * `classes` folder
 * `lib` folder (optional - if the plugin used third party libraries)
 
 The plugin manager searches plugins metadata using a **PluginDescriptorFinder**.   
-**DefaultPluginDescriptorFinder** lookups plugins descriptors in MANIFEST.MF file.
+**DefaultPluginDescriptorFinder** is a "link" to **ManifestPluginDescriptorFinder** that lookups plugins descriptors in MANIFEST.MF file.
 In this case the `classes/META-INF/MANIFEST.MF` file looks like:
 
     Manifest-Version: 1.0
@@ -102,7 +102,7 @@ You can define an extension point in your application using **ExtensionPoint** i
     }
 
 Another important internal component is **ExtensionFinder** that describes how plugin manager discovers extensions for extensions points.   
-**DefaultExtensionFinder** looks up extensions using **Extension** annotation.
+**DefaultExtensionFinder** is a "link" to **SezpozExtensionFinder** that looks up extensions using **Extension** annotation.
 
     public class WelcomePlugin extends Plugin {
 
@@ -135,7 +135,7 @@ The output is:
     >>> Welcome
     >>> Hello
 
-You can inject your custom component (for example PluginDescriptorFinder, ExtensionFinder) in DefaultPluginManager just override createXXX methods (factory method pattern).
+You can inject your custom component (for example PluginDescriptorFinder, ExtensionFinder, PluginClasspath, ...) in DefaultPluginManager just override createXXX methods (factory method pattern).
 
 Example:
 
@@ -154,6 +154,23 @@ and in plugin respository you must have a plugin.properties file with the below
 
 For more information please see the demo sources.
 
+Development runtime mode
+--------------------------
+PF4J can run in two modes: **DEVELOPMENT** and **DEPLOYMENT**.  
+The DEPLOYMENT(default) mode is the standard workflow for plugins creation: create a new maven module for each plugin, codding the plugin (declares new extension points and/or 
+add new extensions), pack the plugin in a zip file, deploy the zip file to plugins folder. These operations are time consuming and from this reason I introduced the DEVELOPMENT runtime mode.  
+The main advantage of DEVELOPMENT runtime mode for a plugin developer is that he/she is not enforced to pack and deploy the plugins. In DEVELOPMENT mode you can developing plugins in a simple and fast mode.   
+
+Lets describe how DEVELOPMENT runtime mode works.
+
+First, you can change the runtime mode using the "pf4j.mode" system property or overriding __DefaultPluginManager.getRuntimeMode()__.  
+For example I run the pf4j demo in eclipse in DEVELOPMENT mode adding only `"-Dpf4j.mode=development"` to the pf4j demo launcher.  
+You can retrieve the current runtime mode using __PluginManager.getRuntimeMode()__ or in your Plugin implementation with __getWrapper().getRuntimeMode()__(see [WelcomeMessage](https://github.com/decebals/pf4j/blob/master/demo/plugins/plugin1/src/main/java/ro/fortsoft/pf4j/demo/welcome/WelcomePlugin.java)).   
+The DefaultPluginManager determines automatically the correct runtime mode and for DEVELOPMENT mode overrides some components(pluginsDirectory is "../plugins", PropertiesPluginDescriptorFinder as PluginDescriptorFinder, DevelopmentPluginClasspath as PluginClassPath).
+Another advantage of DEVELOPMENT runtime mode is that you can execute some code lines only in this mode (for example more debug messages). 
+
+For more details see the demo application. 
+
 Enable/Disable plugins
 -------------------
 In theory, it's a relation **1:N** between an extension point and the extensions for this extension point.   
@@ -191,8 +208,8 @@ If a file with enabled.txt exists than disabled.txt is ignored. See enabled.txt
 Demo
 -------------------
 I have a tiny demo application. The demo application is in demo folder.
-In demo/api folder I declared an extension point (_Greeting_).  
+In demo/api folder I declared an extension point ( _Greeting_).  
-In demo/plugin* I implemented two plugins: plugin1, plugin2 (each plugin adds an extension for _Greeting_).  
+In demo/plugins I implemented two plugins: plugin1, plugin2 (each plugin adds an extension for _Greeting_).  
 
 To run the demo application use:  
  

demo/app/src/main/java/ro/fortsoft/pf4j/demo/Boot.java

@@ -12,19 +12,12 @@
  */
 package ro.fortsoft.pf4j.demo;
 
-import java.io.File;
-import java.util.HashMap;
 import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
 
 import org.apache.commons.lang.StringUtils;
 
 import ro.fortsoft.pf4j.DefaultPluginManager;
-import ro.fortsoft.pf4j.PluginClasspath;
-import ro.fortsoft.pf4j.PluginDescriptorFinder;
 import ro.fortsoft.pf4j.PluginManager;
-import ro.fortsoft.pf4j.PropertiesPluginDescriptorFinder;
 import ro.fortsoft.pf4j.demo.api.Greeting;
 
 /**
@@ -39,7 +32,7 @@ public class Boot {
     	printLogo();
     	
     	// create the plugin manager
-        final PluginManager pluginManager = createPluginManager();
+        final PluginManager pluginManager = new DefaultPluginManager();
         
         // load and start (active/resolved) the plugins
         pluginManager.loadPlugins();
@@ -65,81 +58,10 @@ public class Boot {
         */
     }    
 
-    private static PluginManager createPluginManager() {
-    	// retrieves the pf4j runtime mode
-    	String modeAsString = System.getProperty("pf4j.mode", RuntimeMode.PROD.toString());
-    	RuntimeMode mode = RuntimeMode.byName(modeAsString);
-
-    	System.out.println("PF4J runtime mode: '" + mode + "'");
-    	
-    	// create the plugin manager depending on runtime mode
-    	PluginManager pluginManager = null;
-    	if (mode == RuntimeMode.PROD) {
-    		pluginManager = new DefaultPluginManager();
-    	} else if (mode == RuntimeMode.DEV) {
-    		// run from eclipse IDE (for example)
-    		pluginManager = new DefaultPluginManager(new File("../plugins")) {
-
-				@Override
-				protected PluginClasspath createPluginClasspath() {
-					PluginClasspath pluginClasspath = super.createPluginClasspath();
-					// modify plugin classes
-					List<String> pluginClasses = pluginClasspath.getClassesDirectories();
-					pluginClasses.clear();
-					pluginClasses.add("target/classes");
-					
-					return pluginClasspath;
-				}
-	
-				@Override
-				protected PluginDescriptorFinder createPluginDescriptorFinder() {
-					return new PropertiesPluginDescriptorFinder();
-				}
-				
-    		};
-        }
-    	    	
-    	return pluginManager;
-    }
-
 	private static void printLogo() {
     	System.out.println(StringUtils.repeat("#", 40));
     	System.out.println(StringUtils.center("PF4J-DEMO", 40));
     	System.out.println(StringUtils.repeat("#", 40));		
 	}
 	
-	public enum RuntimeMode {
-		
-		DEV("dev"), // development
-	    PROD("prod"); // production		
-
-	    private final String name;
-	    
-		private static final Map<String, RuntimeMode> map = new HashMap<String, RuntimeMode>();
-		
-		static {
-			for (RuntimeMode mode : RuntimeMode.values()) {
-				map.put(mode.name, mode);
-			}
-		}
-		
-		private RuntimeMode(final String name) {
-	        this.name = name;
-	    }
-
-	    @Override
-	    public String toString() {
-	        return name;
-	    }
-		
-	    public static RuntimeMode byName(String name) {
-	    	if (map.containsKey(name)) {
-	    		return map.get(name);
-	    	}
-
-	    	throw new NoSuchElementException("Cannot found PF4J runtime mode with name '" + name + "'");
-	    }
-	    
-	}
-
 }

demo/plugins/plugin1/pom.xml

@@ -113,19 +113,11 @@
     </build>        
 
     <dependencies>
-        <dependency>
+		<dependency>
-            <groupId>ro.fortsoft.pf4j</groupId>
+			<groupId>commons-lang</groupId>
-            <artifactId>pf4j</artifactId>
+			<artifactId>commons-lang</artifactId>
-            <version>${project.version}</version>
+			<version>2.6</version>
-            <scope>provided</scope>
+		</dependency>
-        </dependency>    
-
-        <dependency>
-            <groupId>ro.fortsoft.pf4j.demo</groupId>
-            <artifactId>pf4j-demo-api</artifactId>
-            <version>${project.version}</version>
-            <scope>provided</scope>
-        </dependency>
     </dependencies>
     
 </project>

demo/plugins/plugin1/src/main/java/ro/fortsoft/pf4j/demo/welcome/WelcomePlugin.java

@@ -12,9 +12,12 @@
  */
 package ro.fortsoft.pf4j.demo.welcome;
 
+import org.apache.commons.lang.StringUtils;
+
 import ro.fortsoft.pf4j.Extension;
 import ro.fortsoft.pf4j.Plugin;
 import ro.fortsoft.pf4j.PluginWrapper;
+import ro.fortsoft.pf4j.RuntimeMode;
 import ro.fortsoft.pf4j.demo.api.Greeting;
 
 /**
@@ -26,10 +29,16 @@ public class WelcomePlugin extends Plugin {
         super(wrapper);
     }
 
+    @Override
     public void start() {
         System.out.println("WelcomePlugin.start()");
+        // for testing the development mode
+        if (RuntimeMode.DEVELOPMENT.equals(wrapper.getRuntimeMode())) {
+        	System.out.println(StringUtils.upperCase("WelcomePlugin"));
+        }
     }
 
+    @Override
     public void stop() {
         System.out.println("WelcomePlugin.stop()");
     }
@@ -37,6 +46,7 @@ public class WelcomePlugin extends Plugin {
     @Extension
     public static class WelcomeGreeting implements Greeting {
 
+    	@Override
         public String getGreeting() {
             return "Welcome";
         }

demo/plugins/plugin2/pom.xml

@@ -112,20 +112,4 @@
         </plugins>
     </build>        
 
-    <dependencies>
-        <dependency>
-            <groupId>ro.fortsoft.pf4j</groupId>
-            <artifactId>pf4j</artifactId>
-            <version>${project.version}</version>
-            <scope>provided</scope>
-        </dependency>    
-
-        <dependency>
-            <groupId>ro.fortsoft.pf4j.demo</groupId>
-            <artifactId>pf4j-demo-api</artifactId>
-            <version>${project.version}</version>
-            <scope>provided</scope>
-        </dependency>
-    </dependencies>
-
 </project>

demo/plugins/plugin2/src/main/java/ro/fortsoft/pf4j/demo/hello/HelloPlugin.java

@@ -28,10 +28,12 @@ public class HelloPlugin extends Plugin {
         super(wrapper);
     }
 
+    @Override
     public void start() {
         System.out.println("HelloPlugin.start()");
     }
 
+    @Override
     public void stop() {
         System.out.println("HelloPlugin.stop()");
     }
@@ -39,6 +41,7 @@ public class HelloPlugin extends Plugin {
     @Extension
     public static class HelloGreeting implements Greeting {
 
+    	@Override
         public String getGreeting() {
             return "Hello";
         }

demo/plugins/pom.xml

@@ -27,6 +27,59 @@
                 <directory>src/main/resources</directory>
             </resource>
         </resources>
+        
+        <plugins>
+            <plugin>
+                <artifactId>maven-dependency-plugin</artifactId>
+                <executions>
+                    <execution>
+                        <phase>process-sources</phase>
+                        <goals>
+                            <goal>copy-dependencies</goal>
+                        </goals>
+                        <configuration>
+                            <outputDirectory>${project.build.directory}/lib</outputDirectory>
+                            <excludeScope>provided</excludeScope>
+                        </configuration>
+                    </execution>
+                </executions>
+            </plugin>
+        </plugins>
+
+		<pluginManagement>
+			<plugins>
+				<plugin>
+					<groupId>org.eclipse.m2e</groupId>
+					<artifactId>lifecycle-mapping</artifactId>
+					<version>1.0.0</version>
+					<configuration>
+						<lifecycleMappingMetadata>
+							<pluginExecutions>
+								<pluginExecution>
+									<pluginExecutionFilter>
+										<groupId>org.apache.maven.plugins</groupId>
+										<artifactId>maven-dependency-plugin</artifactId>
+										<versionRange>[2.0,)</versionRange>
+										<goals>
+											<goal>copy-dependencies</goal>
+										</goals>
+									</pluginExecutionFilter>
+									<action>
+										<!--
+										<execute/>
+										-->
+										<execute>
+											<runOnIncremental>true</runOnIncremental>
+											<runOnConfiguration>true</runOnConfiguration>
+										</execute>
+									</action>
+								</pluginExecution>
+							</pluginExecutions>
+						</lifecycleMappingMetadata>
+					</configuration>
+				</plugin>
+			</plugins>
+		</pluginManagement>
     </build>
 
     <modules>
@@ -34,4 +87,20 @@
         <module>plugin2</module>
     </modules>
 
+    <dependencies>
+        <dependency>
+            <groupId>ro.fortsoft.pf4j</groupId>
+            <artifactId>pf4j</artifactId>
+            <version>${project.version}</version>
+            <scope>provided</scope>
+        </dependency>    
+
+        <dependency>
+            <groupId>ro.fortsoft.pf4j.demo</groupId>
+            <artifactId>pf4j-demo-api</artifactId>
+            <version>${project.version}</version>
+            <scope>provided</scope>
+        </dependency>
+    </dependencies>
+    
 </project>

pf4j/src/main/java/ro/fortsoft/pf4j/DefaultPluginManager.java

@@ -16,6 +16,7 @@ import java.io.File;
 import java.io.FileFilter;
 import java.io.IOException;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
@@ -42,16 +43,19 @@ public class DefaultPluginManager implements PluginManager {
 
 	private static final Logger log = LoggerFactory.getLogger(DefaultPluginManager.class);
 	
+	public static final String DEFAULT_PLUGINS_DIRECTORY = "plugins";
+	public static final String DEVELOPMENT_PLUGINS_DIRECTORY = "../plugins";
+
     /**
      * The plugins repository.
      */
     private File pluginsDirectory;
 
-    private final ExtensionFinder extensionFinder;
+    private ExtensionFinder extensionFinder;
     
-    private final PluginDescriptorFinder pluginDescriptorFinder;
+    private PluginDescriptorFinder pluginDescriptorFinder;
     
-    private final PluginClasspath pluginClasspath;
+    private PluginClasspath pluginClasspath;
     
     /**
      * A map of plugins this manager is responsible for (the key is the 'pluginId').
@@ -92,10 +96,18 @@ public class DefaultPluginManager implements PluginManager {
     protected CompoundClassLoader compoundClassLoader;
     
     /**
-     * Th plugins directory is supplied by System.getProperty("pf4j.pluginsDir", "plugins").
+     * Cache value for the runtime mode. No need to re-read it because it wont change at
+	 * runtime.
+     */
+    private RuntimeMode runtimeMode;
+    
+    /**
+     * The plugins directory is supplied by System.getProperty("pf4j.pluginsDir", "plugins").
      */
     public DefaultPluginManager() {
-    	this(new File(System.getProperty("pf4j.pluginsDir", "plugins")));
+    	this.pluginsDirectory = createPluginsDirectory();
+    	
+    	initialize();
     }
     
     /**
@@ -107,32 +119,7 @@ public class DefaultPluginManager implements PluginManager {
     public DefaultPluginManager(File pluginsDirectory) {
         this.pluginsDirectory = pluginsDirectory;
         
-        plugins = new HashMap<String, PluginWrapper>();
+        initialize();
-        pluginClassLoaders = new HashMap<String, PluginClassLoader>();
-        pathToIdMap = new HashMap<String, String>();
-        unresolvedPlugins = new ArrayList<PluginWrapper>();
-        resolvedPlugins = new ArrayList<PluginWrapper>();
-        startedPlugins = new ArrayList<PluginWrapper>();
-        disabledPlugins = new ArrayList<String>();
-        compoundClassLoader = new CompoundClassLoader();
-        
-        pluginClasspath = createPluginClasspath();
-        pluginDescriptorFinder = createPluginDescriptorFinder();
-        extensionFinder = createExtensionFinder();
-
-        try {
-        	// create a list with plugin identifiers that should be only accepted by this manager (whitelist from plugins/enabled.txt file)
-        	enabledPlugins = FileUtils.readLines(new File(pluginsDirectory, "enabled.txt"), true);
-        	log.info("Enabled plugins: {}", enabledPlugins);
-        	
-        	// create a list with plugin identifiers that should not be accepted by this manager (blacklist from plugins/disabled.txt file)
-        	disabledPlugins = FileUtils.readLines(new File(pluginsDirectory, "disabled.txt"), true);
-        	log.info("Disabled plugins: {}", disabledPlugins);
-        } catch (IOException e) {
-        	log.error(e.getMessage(), e);
-        }
-
-        System.setProperty("pf4j.pluginsDir", pluginsDirectory.getAbsolutePath());
     }
 
 	@Override
@@ -223,6 +210,7 @@ public class DefaultPluginManager implements PluginManager {
         filterList.add(new NotFileFilter(createHiddenPluginFilter()));
         FileFilter pluginsFilter = new AndFileFilter(filterList);
         File[] directories = pluginsDirectory.listFiles(pluginsFilter);
+        log.debug("Possible plugins: {}", Arrays.asList(directories));
         if (directories.length == 0) {
         	log.info("No plugins");
         	return;
@@ -264,6 +252,20 @@ public class DefaultPluginManager implements PluginManager {
 		return extensions;
 	}
 	
+    @Override
+	public RuntimeMode getRuntimeMode() {
+    	if (runtimeMode == null) {
+        	// retrieves the runtime mode from system  
+        	String modeAsString = System.getProperty("pf4j.mode", RuntimeMode.DEPLOYMENT.toString());
+        	runtimeMode = RuntimeMode.byName(modeAsString);
+
+        	log.info("PF4J runtime mode: '" + runtimeMode + "'");
+
+    	}
+    	
+		return runtimeMode;
+	}
+	
     /**
      * Retrieves the {@link PluginWrapper} that loaded the given class 'clazz'.
      */
@@ -280,8 +282,15 @@ public class DefaultPluginManager implements PluginManager {
 
 	/**
 	 * Add the possibility to override the PluginDescriptorFinder. 
+	 * By default if getRuntimeMode() returns RuntimeMode.DEVELOPMENT than a 
+	 * PropertiesPluginDescriptorFinder is returned else this method returns 
+	 * DefaultPluginDescriptorFinder.
 	 */
     protected PluginDescriptorFinder createPluginDescriptorFinder() {
+    	if (RuntimeMode.DEVELOPMENT.equals(getRuntimeMode())) {
+    		return new PropertiesPluginDescriptorFinder();
+    	}
+    	
     	return new DefaultPluginDescriptorFinder(pluginClasspath);
     }
 
@@ -294,8 +303,15 @@ public class DefaultPluginManager implements PluginManager {
 
     /**
      * Add the possibility to override the PluginClassPath. 
+     * By default if getRuntimeMode() returns RuntimeMode.DEVELOPMENT than a 
+	 * DevelopmentPluginClasspath is returned else this method returns 
+	 * PluginClasspath.
      */
     protected PluginClasspath createPluginClasspath() {
+    	if (RuntimeMode.DEVELOPMENT.equals(getRuntimeMode())) {
+    		return new DevelopmentPluginClasspath();
+    	}
+    	
     	return new PluginClasspath();
     }
     
@@ -311,6 +327,57 @@ public class DefaultPluginManager implements PluginManager {
     	return new HiddenFilter();
     }
     
+    /**
+     * Add the possibility to override the plugins directory.
+     * If a "pf4j.pluginsDir" system property is defined than this method returns
+     * that directory.
+     * If getRuntimeMode() returns RuntimeMode.DEVELOPMENT than a 
+	 * DEVELOPMENT_PLUGINS_DIRECTORY ("../plugins") is returned else this method returns 
+	 * DEFAULT_PLUGINS_DIRECTORY ("plugins").
+     * @return
+     */
+    protected File createPluginsDirectory() {
+    	String pluginsDir = System.getProperty("pf4j.pluginsDir");
+    	if (pluginsDir == null) {
+    		if (RuntimeMode.DEVELOPMENT.equals(getRuntimeMode())) {
+    			pluginsDir = DEVELOPMENT_PLUGINS_DIRECTORY;
+    		} else {
+    			pluginsDir = DEFAULT_PLUGINS_DIRECTORY;
+    		}
+    	}
+    	
+    	return new File(pluginsDir);
+    }
+    
+	private void initialize() {
+		plugins = new HashMap<String, PluginWrapper>();
+        pluginClassLoaders = new HashMap<String, PluginClassLoader>();
+        pathToIdMap = new HashMap<String, String>();
+        unresolvedPlugins = new ArrayList<PluginWrapper>();
+        resolvedPlugins = new ArrayList<PluginWrapper>();
+        startedPlugins = new ArrayList<PluginWrapper>();
+        disabledPlugins = new ArrayList<String>();
+        compoundClassLoader = new CompoundClassLoader();
+        
+        pluginClasspath = createPluginClasspath();
+        pluginDescriptorFinder = createPluginDescriptorFinder();
+        extensionFinder = createExtensionFinder();
+
+        try {
+        	// create a list with plugin identifiers that should be only accepted by this manager (whitelist from plugins/enabled.txt file)
+        	enabledPlugins = FileUtils.readLines(new File(pluginsDirectory, "enabled.txt"), true);
+        	log.info("Enabled plugins: {}", enabledPlugins);
+        	
+        	// create a list with plugin identifiers that should not be accepted by this manager (blacklist from plugins/disabled.txt file)
+        	disabledPlugins = FileUtils.readLines(new File(pluginsDirectory, "disabled.txt"), true);
+        	log.info("Disabled plugins: {}", disabledPlugins);
+        } catch (IOException e) {
+        	log.error(e.getMessage(), e);
+        }
+
+        System.setProperty("pf4j.pluginsDir", pluginsDirectory.getAbsolutePath());
+	}
+
 	private void loadPlugin(File pluginDirectory) throws PluginException {
         // try to load the plugin
 		String pluginName = pluginDirectory.getName();
@@ -343,6 +410,7 @@ public class DefaultPluginManager implements PluginManager {
         // create the plugin wrapper
         log.debug("Creating wrapper for plugin '{}'", pluginPath);
         PluginWrapper pluginWrapper = new PluginWrapper(pluginDescriptor, pluginPath, pluginLoader.getPluginClassLoader());
+        pluginWrapper.setRuntimeMode(getRuntimeMode());
         log.debug("Created wrapper '{}' for plugin '{}'", pluginWrapper, pluginPath);
 
         String pluginId = pluginDescriptor.getPluginId();

pf4j/src/main/java/ro/fortsoft/pf4j/DevelopmentPluginClasspath.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2013 Decebal Suiu
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with
+ * the License. You may obtain a copy of the License in the LICENSE file, or 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 ro.fortsoft.pf4j;
+
+/**
+ * Overwrite classes directories to "target/classes" and lib directories to "target/lib".
+ *  
+ * @author Decebal Suiu
+ */
+public class DevelopmentPluginClasspath extends PluginClasspath {
+
+	private static final String DEVELOPMENT_CLASSES_DIRECTORY = "target/classes";
+	private static final String DEVELOPMENT_LIB_DIRECTORY = "target/lib";
+	
+	public DevelopmentPluginClasspath() {
+		super();
+	}
+
+	@Override
+	protected void addResources() {
+		classesDirectories.add(DEVELOPMENT_CLASSES_DIRECTORY);
+		libDirectories.add(DEVELOPMENT_LIB_DIRECTORY);
+	}
+
+	
+}

pf4j/src/main/java/ro/fortsoft/pf4j/PluginClasspath.java

@@ -28,16 +28,14 @@ public class PluginClasspath {
 	private static final String DEFAULT_CLASSES_DIRECTORY = "classes";
 	private static final String DEFAULT_LIB_DIRECTORY = "lib";
 	
-	private List<String> classesDirectories;
+	protected List<String> classesDirectories;
-	private List<String> libDirectories;
+	protected List<String> libDirectories;
 	
 	public PluginClasspath() {
 		classesDirectories = new ArrayList<String>();
 		libDirectories = new ArrayList<String>();
 		
-		// add defaults
+		addResources();
-		classesDirectories.add(DEFAULT_CLASSES_DIRECTORY);
-		libDirectories.add(DEFAULT_LIB_DIRECTORY);
 	}
 
 	public List<String> getClassesDirectories() {
@@ -56,4 +54,9 @@ public class PluginClasspath {
 		this.libDirectories = libDirectories;
 	}
 	
+	protected void addResources() {
+		classesDirectories.add(DEFAULT_CLASSES_DIRECTORY);
+		libDirectories.add(DEFAULT_LIB_DIRECTORY);		
+	}
+	
 }

pf4j/src/main/java/ro/fortsoft/pf4j/PluginManager.java

@@ -61,4 +61,9 @@ public interface PluginManager {
 
 	public <T> List<T> getExtensions(Class<T> type);
 	
+	/**
+	 * The runtime mode. Must currently be either DEVELOPMENT or DEPLOYMENT.
+	 */
+	public RuntimeMode getRuntimeMode();
+	
 }

pf4j/src/main/java/ro/fortsoft/pf4j/PluginWrapper.java

@@ -27,6 +27,7 @@ public class PluginWrapper {
 	PluginClassLoader pluginClassLoader;
 	Plugin plugin;
 	PluginState pluginState;
+	RuntimeMode runtimeMode;
 	
 	public PluginWrapper(PluginDescriptor descriptor, String pluginPath, PluginClassLoader pluginClassLoader) {
 		this.descriptor = descriptor;
@@ -74,6 +75,10 @@ public class PluginWrapper {
 		return pluginState;
 	}
 
+	public RuntimeMode getRuntimeMode() {
+		return runtimeMode;
+	}
+
 	@Override
 	public int hashCode() {
 		final int prime = 31;
@@ -115,6 +120,10 @@ public class PluginWrapper {
 		this.pluginState = pluginState;
 	}
 	
+	void setRuntimeMode(RuntimeMode runtimeMode) {
+		this.runtimeMode = runtimeMode;
+	}
+
 	private Plugin createPluginInstance() throws Exception {
     	String pluginClassName = descriptor.getPluginClass();
         Class<?> pluginClass = pluginClassLoader.loadClass(pluginClassName);

pf4j/src/main/java/ro/fortsoft/pf4j/RuntimeMode.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2013 Decebal Suiu
+ * 
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this work except in compliance with
+ * the License. You may obtain a copy of the License in the LICENSE file, or 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 ro.fortsoft.pf4j;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.NoSuchElementException;
+
+/**
+ * @author Decebal Suiu
+ */
+public enum RuntimeMode {
+	
+	DEVELOPMENT("development"), // development
+    DEPLOYMENT("deployment"); // deployment		
+
+    private final String name;
+    
+	private static final Map<String, RuntimeMode> map = new HashMap<String, RuntimeMode>();
+	
+	static {
+		for (RuntimeMode mode : RuntimeMode.values()) {
+			map.put(mode.name, mode);
+		}
+	}
+	
+	private RuntimeMode(final String name) {
+        this.name = name;
+    }
+
+    @Override
+    public String toString() {
+        return name;
+    }
+	
+    public static RuntimeMode byName(String name) {
+    	if (map.containsKey(name)) {
+    		return map.get(name);
+    	}
+
+    	throw new NoSuchElementException("Cannot found PF4J runtime mode with name '" + name + 
+    			"'. Must be 'development' or 'deployment'.");
+    }
+    
+}