Merge branch 'master' into rerun-formatter-exit-code

Author: aslakhellesoy

History.md

@@ -1,5 +1,8 @@
 ## [1.2.3-SNAPSHOT](https://github.com/cucumber/cucumber-jvm/compare/v1.2.2...master) (In Git)
 
+* [OSGi] Cucumber is ready to run in OSGi containers ([#873](https://github.com/cucumber/cucumber-jvm/pull/873), [#799](https://github.com/cucumber/cucumber-jvm/pull/799) @HendrikSP)
+* [Core] `cucumber.runtime.java.ObjectFactory` moved to `cucumber.api.java.ObjectFactory`. Custom implementation can
+  be specified in `cucumber.properties` with `cucumber.api.java.ObjectFactory=my.special.KindOfObjectFactory`. (Closes [#290](https://github.com/cucumber/cucumber-jvm/issues/290) Aslak Hellesøy)
 * [Core] Properly decode jar URLs with spaces (%20) - ([#866](https://github.com/cucumber/cucumber-jvm/issues/866) Aslak Hellesøy)
 * [Java] Arity mismatch Java8 Step Definition error ([#852](https://github.com/cucumber/cucumber-jvm/issues/852), [#847](https://github.com/cucumber/cucumber-jvm/pull/847) David Coelho)
 * [Java] Print Java 8 lambda snippets when `cucumber-java8` is active (Aslak Hellesøy)

android/src/main/java/cucumber/runtime/android/AndroidObjectFactory.java

@@ -5,17 +5,17 @@
 import android.test.ActivityInstrumentationTestCase2;
 import android.test.AndroidTestCase;
 import android.test.InstrumentationTestCase;
-import cucumber.runtime.java.ObjectFactory;
+import cucumber.api.java.ObjectFactory;
 
 /**
- * Android specific implementation of {@link cucumber.runtime.java.ObjectFactory} which will
+ * Android specific implementation of {@link ObjectFactory} which will
  * make sure that created test classes have all necessary references to the executing {@link android.app.Instrumentation}
  * and the associated {@link android.content.Context}.
  */
 public class AndroidObjectFactory implements ObjectFactory {
 
     /**
-     * The actual {@link cucumber.runtime.java.ObjectFactory} responsible for creating instances.
+     * The actual {@link ObjectFactory} responsible for creating instances.
      */
     private final ObjectFactory delegate;
 
@@ -25,11 +25,11 @@ public class AndroidObjectFactory implements ObjectFactory {
     private final Instrumentation instrumentation;
 
     /**
-     * Creates a new instance using the given delegate {@link cucumber.runtime.java.ObjectFactory} to
+     * Creates a new instance using the given delegate {@link ObjectFactory} to
      * forward all calls to and using the given {@link android.app.Instrumentation} to set to the instantiated
      * android test classes.
      *
-     * @param delegate the {@link cucumber.runtime.java.ObjectFactory} to delegate to
+     * @param delegate the {@link ObjectFactory} to delegate to
      * @param instrumentation the {@link android.app.Instrumentation} to set to the tests
      */
     public AndroidObjectFactory(final ObjectFactory delegate, final Instrumentation instrumentation) {

android/src/main/java/cucumber/runtime/android/CucumberExecutor.java

@@ -8,12 +8,14 @@
 import cucumber.runtime.Backend;
 import cucumber.runtime.ClassFinder;
 import cucumber.runtime.CucumberException;
+import cucumber.runtime.Env;
 import cucumber.runtime.Runtime;
 import cucumber.runtime.RuntimeOptions;
 import cucumber.runtime.RuntimeOptionsFactory;
 import cucumber.runtime.io.ResourceLoader;
 import cucumber.runtime.java.JavaBackend;
-import cucumber.runtime.java.ObjectFactory;
+import cucumber.api.java.ObjectFactory;
+import cucumber.runtime.java.ObjectFactoryLoader;
 import cucumber.runtime.model.CucumberFeature;
 import dalvik.system.DexFile;
 import gherkin.formatter.Formatter;
@@ -155,7 +157,7 @@ private RuntimeOptions createRuntimeOptions(final Context context) {
     }
 
     private Collection<? extends Backend> createBackends() {
-        final ObjectFactory delegateObjectFactory = JavaBackend.loadObjectFactory(classFinder);
+        final ObjectFactory delegateObjectFactory = ObjectFactoryLoader.loadObjectFactory(classFinder, Env.INSTANCE.get(ObjectFactory.class.getName()));
         final AndroidObjectFactory objectFactory = new AndroidObjectFactory(delegateObjectFactory, instrumentation);
         final List<Backend> backends = new ArrayList<Backend>();
         backends.add(new JavaBackend(objectFactory, classFinder));

android/src/main/java/cucumber/runtime/android/DexClassFinder.java

@@ -65,22 +65,22 @@ public <T> Collection<Class<? extends T>> getDescendants(final Class<T> parentTy
         while (entries.hasMoreElements()) {
             final String className = entries.nextElement();
             if (isInPackage(className, packageName) && !isGenerated(className)) {
-                final Class<? extends T> clazz = loadClass(className);
-                if (clazz != null && !parentType.equals(clazz) && parentType.isAssignableFrom(clazz)) {
-                    result.add(clazz.asSubclass(parentType));
+                try {
+                    final Class<? extends T> clazz = loadClass(className);
+                    if (clazz != null && !parentType.equals(clazz) && parentType.isAssignableFrom(clazz)) {
+                        result.add(clazz.asSubclass(parentType));
+                    }
+                } catch (ClassNotFoundException e) {
+                    throw new CucumberException(e);
                 }
             }
         }
         return result;
     }
 
-    @SuppressWarnings("unchecked")
-    private <T> Class<? extends T> loadClass(final String className) {
-        try {
-            return (Class<? extends T>) Class.forName(className, false, CLASS_LOADER);
-        } catch (final ClassNotFoundException e) {
-            throw new CucumberException(e);
-        }
+    @Override
+    public <T> Class<? extends T> loadClass(final String className) throws ClassNotFoundException {
+        return (Class<? extends T>) Class.forName(className, false, CLASS_LOADER);
     }
 
     private boolean isInPackage(final String className, final String packageName) {

android/src/test/java/cucumber/runtime/android/AndroidObjectFactoryTest.java

@@ -6,7 +6,7 @@
 import android.test.ActivityInstrumentationTestCase2;
 import android.test.AndroidTestCase;
 import android.test.InstrumentationTestCase;
-import cucumber.runtime.java.ObjectFactory;
+import cucumber.api.java.ObjectFactory;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.robolectric.RobolectricTestRunner;

core/pom.xml

@@ -86,6 +86,7 @@
                 <artifactId>maven-jar-plugin</artifactId>
                 <configuration>
                     <archive>
+                        <manifestFile>${project.build.outputDirectory}/META-INF/MANIFEST.MF</manifestFile>
                         <manifest>
                             <mainClass>cucumber.api.cli.Main</mainClass>
                         </manifest>
@@ -101,6 +102,18 @@
                 </configuration>
             </plugin>
 
+            <plugin>
+                <groupId>org.apache.felix</groupId>
+                <artifactId>maven-bundle-plugin</artifactId>
+                <configuration>
+                    <instructions>
+                        <Bundle-Description></Bundle-Description>
+                        <Export-Package>cucumber.*</Export-Package>
+                        <DynamicImport-Package>*</DynamicImport-Package>
+                    </instructions>
+                </configuration>
+            </plugin>
+
         </plugins>
     </build>
 </project>

core/src/main/java/cucumber/runtime/ClassFinder.java

@@ -4,4 +4,6 @@
 
 public interface ClassFinder {
     <T> Collection<Class<? extends T>> getDescendants(Class<T> parentType, String packageName);
+
+    <T> Class<? extends T> loadClass(String className) throws ClassNotFoundException;
 }

core/src/main/java/cucumber/runtime/Env.java

@@ -1,5 +1,7 @@
 package cucumber.runtime;
 
+import java.util.HashMap;
+import java.util.Map;
 import java.util.MissingResourceException;
 import java.util.Properties;
 import java.util.ResourceBundle;
@@ -13,8 +15,8 @@
  * </ol>
  */
 public class Env {
-    private final String bundleName;
-    private final Properties properties;
+    public static final Env INSTANCE = new Env("cucumber");
+    private final Map<String, String> map = new HashMap<String, String>();
 
     public Env() {
         this(null, System.getProperties());
@@ -29,64 +31,41 @@ public Env(Properties properties) {
     }
 
     public Env(String bundleName, Properties properties) {
-        this.bundleName = bundleName;
-        this.properties = properties;
-    }
+        if (bundleName != null) {
+            try {
+                ResourceBundle bundle = ResourceBundle.getBundle(bundleName);
+                for (String key : bundle.keySet()) {
+                    put(key, bundle.getString(key));
+                }
+            } catch (MissingResourceException ignore) {
+            }
+        }
 
-    public String get(String key) {
-        String result = getFromEnvironment(key);
-        if (result == null) {
-            result = getFromProperty(key);
-            if (result == null && bundleName != null) {
-                result = getFromBundle(key);
+        if (properties != null) {
+            for (String key : properties.stringPropertyNames()) {
+                put(key, properties.getProperty(key));
             }
         }
-        return result;
-    }
 
-    private String getFromEnvironment(String key) {
-        String value = System.getenv(asEnvKey(key));
-        if (value == null) {
-            value = System.getenv(asPropertyKey(key));
+        Map<String, String> env = System.getenv();
+        for (String key : env.keySet()) {
+            put(key, env.get(key));
         }
-        return value;
     }
 
-    private String getFromProperty(String key) {
-        String value = properties.getProperty(asEnvKey(key));
-        if (value == null) {
-            value = properties.getProperty(asPropertyKey(key));
-        }
-        return value;
+    private void put(String key, String string) {
+        map.put(key, string);
+        // Support old skool
+        map.put(key.replace('.', '_').toUpperCase(), string);
+        map.put(key.replace('_', '.').toLowerCase(), string);
     }
 
-    private String getFromBundle(String key) {
-        try {
-            ResourceBundle bundle = ResourceBundle.getBundle(bundleName);
-            try {
-                return bundle.getString(asEnvKey(key));
-            } catch (MissingResourceException stringNotFound) {
-                try {
-                    return bundle.getString(asPropertyKey(key));
-                } catch (MissingResourceException ignoreStringNotFound) {
-                    return bundle.getString(asPropertyKey(key));
-                }
-            }
-        } catch (MissingResourceException ignoreBundleNotFound) {
-            return null;
-        }
+    public String get(String key) {
+        return map.get(key);
     }
 
     public String get(String key, String defaultValue) {
         String result = get(key);
         return result != null ? result : defaultValue;
     }
-
-    private static String asEnvKey(String key) {
-        return key.replace('.', '_').toUpperCase();
-    }
-
-    private static String asPropertyKey(String key) {
-        return key.replace('_', '.').toLowerCase();
-    }
 }

core/src/main/java/cucumber/runtime/RuntimeOptions.java

@@ -14,6 +14,8 @@
 import gherkin.formatter.Reporter;
 import gherkin.util.FixJava;
 
+import java.io.InputStreamReader;
+import java.io.Reader;
 import java.lang.reflect.InvocationHandler;
 import java.lang.reflect.Method;
 import java.lang.reflect.Proxy;
@@ -27,7 +29,9 @@
 // IMPORTANT! Make sure USAGE.txt is always uptodate if this class changes.
 public class RuntimeOptions {
     public static final String VERSION = ResourceBundle.getBundle("cucumber.version").getString("cucumber-jvm.version");
-    public static final String USAGE = FixJava.readResource("/cucumber/api/cli/USAGE.txt");
+    public static final String USAGE_RESOURCE = "/cucumber/api/cli/USAGE.txt";
+
+    static String usageText;
 
     private final List<String> glue = new ArrayList<String>();
     private final List<Object> filters = new ArrayList<Object>();
@@ -70,7 +74,7 @@ public RuntimeOptions(Env env, List<String> argv) {
     }
 
     public RuntimeOptions(PluginFactory pluginFactory, List<String> argv) {
-        this(new Env("cucumber"), pluginFactory, argv);
+        this(Env.INSTANCE, pluginFactory, argv);
     }
 
     public RuntimeOptions(Env env, PluginFactory pluginFactory, List<String> argv) {
@@ -187,7 +191,19 @@ private void stripLinesFromFeaturePaths(List<String> featurePaths) {
     }
 
     private void printUsage() {
-        System.out.println(USAGE);
+        loadUsageTextIfNeeded();
+        System.out.println(usageText);
+    }
+
+    static void loadUsageTextIfNeeded() {
+        if (usageText == null) {
+            try {
+                Reader reader = new InputStreamReader(FixJava.class.getResourceAsStream(USAGE_RESOURCE), "UTF-8");
+                usageText = FixJava.readReader(reader);
+            } catch (Exception e) {
+                usageText = "Could not load usage text: " + e.toString();
+            }
+        }
     }
 
     private int printI18n(String language) {

core/src/main/java/cucumber/runtime/io/ResourceLoaderClassFinder.java

@@ -21,21 +21,20 @@ public <T> Collection<Class<? extends T>> getDescendants(Class<T> parentType, St
         String packagePath = "classpath:" + packageName.replace('.', '/').replace(File.separatorChar, '/');
         for (Resource classResource : resourceLoader.resources(packagePath, ".class")) {
             String className = classResource.getClassName(".class");
-            Class<?> clazz = loadClass(className, classLoader);
-            if (clazz != null && !parentType.equals(clazz) && parentType.isAssignableFrom(clazz)) {
-                result.add(clazz.asSubclass(parentType));
+
+            try {
+                Class<?> clazz = loadClass(className);
+                if (clazz != null && !parentType.equals(clazz) && parentType.isAssignableFrom(clazz)) {
+                    result.add(clazz.asSubclass(parentType));
+                }
+            } catch (ClassNotFoundException ignore) {
+            } catch (NoClassDefFoundError ignore) {
             }
         }
         return result;
     }
 
-    private Class<?> loadClass(String className, ClassLoader classLoader) {
-        try {
-            return classLoader.loadClass(className);
-        } catch (ClassNotFoundException ignore) {
-            return null;
-        } catch (NoClassDefFoundError ignore) {
-            return null;
-        }
+    public <T> Class<? extends T> loadClass(String className) throws ClassNotFoundException {
+        return (Class<? extends T>) classLoader.loadClass(className);
     }
 }