Merge pull request #216 from KristianKarl/add_possibility_to_pickup_generators_from_classpath

Scan and use plugin generators

Author: KristianKarl

graphwalker-dsl/pom.xml

@@ -29,6 +29,14 @@
             <groupId>org.antlr</groupId>
             <artifactId>antlr4-runtime</artifactId>
         </dependency>
+      <dependency>
+        <groupId>org.reflections</groupId>
+        <artifactId>reflections</artifactId>
+      </dependency>
+      <dependency>
+        <groupId>commons-io</groupId>
+        <artifactId>commons-io</artifactId>
+      </dependency>
     </dependencies>
 
     <build>

graphwalker-dsl/src/main/java/org/graphwalker/dsl/antlr/generator/GeneratorFactoryException.java

@@ -0,0 +1,42 @@
+package org.graphwalker.dsl.antlr.generator;
+
+/*
+ * #%L
+ * GraphWalker Input/Output
+ * %%
+ * Copyright (C) 2005 - 2014 GraphWalker
+ * %%
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ * #L%
+ */
+
+public class GeneratorFactoryException extends RuntimeException {
+
+  public GeneratorFactoryException() {
+    super();
+  }
+
+  public GeneratorFactoryException(String message) {
+    super(message);
+  }
+
+  public GeneratorFactoryException(String message, Throwable t) {
+    super(message, t);
+  }
+}

graphwalker-dsl/src/main/java/org/graphwalker/dsl/antlr/generator/GeneratorFactoryScanner.java

@@ -0,0 +1,85 @@
+package org.graphwalker.dsl.antlr.generator;
+
+/*
+ * #%L
+ * GraphWalker Input/Output
+ * %%
+ * Copyright (C) 2005 - 2014 GraphWalker
+ * %%
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in
+ * all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+ * THE SOFTWARE.
+ * #L%
+ */
+
+import org.apache.commons.io.FilenameUtils;
+import org.graphwalker.core.generator.PathGeneratorBase;
+import org.reflections.Reflections;
+import org.reflections.scanners.SubTypesScanner;
+import org.reflections.util.ClasspathHelper;
+import org.reflections.util.ConfigurationBuilder;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.net.URL;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Set;
+
+public final class GeneratorFactoryScanner {
+
+  private GeneratorFactoryScanner() {
+  }
+
+  private static final Logger logger = LoggerFactory.getLogger(GeneratorFactoryScanner.class);
+
+  static {
+    Reflections.log = null;
+  }
+
+  private static boolean valid(URL url) {
+    String extension = FilenameUtils.getExtension(url.getPath());
+    return "".equals(extension) || "jar".equals(extension);
+  }
+
+  private static Collection<URL> getUrls() {
+    Set<URL> filteredUrls = new HashSet<>();
+    Set<URL> urls = new HashSet<>();
+    urls.addAll(ClasspathHelper.forClassLoader());
+    urls.addAll(ClasspathHelper.forJavaClassPath());
+    for (URL url : urls) {
+      if (valid(url)) {
+        logger.debug(url.toString());
+        filteredUrls.add(url);
+      }
+    }
+    return filteredUrls;
+  }
+
+  public static Class get(String generator) {
+    return get(new Reflections(new ConfigurationBuilder().addUrls(getUrls()).addScanners(new SubTypesScanner())), generator);
+  }
+
+  public static Class get(Reflections reflections, String generatorString) {
+    for (Class<? extends PathGeneratorBase> generatorClass : reflections.getSubTypesOf(PathGeneratorBase.class)) {
+      if (generatorClass.getSimpleName().equalsIgnoreCase(generatorString)) {
+        return generatorClass;
+      }
+    }
+    throw new GeneratorFactoryException("No suitable generator found with name: " + generatorString);
+  }
+}

graphwalker-dsl/src/main/java/org/graphwalker/dsl/antlr/generator/GeneratorLoader.java

@@ -26,6 +26,7 @@
  * #L%
  */
 
+import java.lang.reflect.InvocationTargetException;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.TimeUnit;
@@ -110,6 +111,13 @@ public void exitGenerator(GeneratorParser.GeneratorContext context) {
       pathGenerators.add(new AStarPath((ReachedStopCondition) stopCondition));
     } else if ("shortest_all_paths".equals(generatorName) || "shortestallpaths".equals(generatorName)) {
       pathGenerators.add(new ShortestAllPaths(stopCondition));
+    } else {
+      Class generatorClass = GeneratorFactoryScanner.get(generatorName);
+      try {
+        pathGenerators.add((PathGenerator) generatorClass.getConstructor(StopCondition.class).newInstance(stopCondition));
+      } catch (Exception e) {
+        throw new GeneratorFactoryException("No suitable generator found with name: " + generatorName + ", because: " + e.getCause());
+      }
     }
     stopConditions.clear();
   }

graphwalker-dsl/src/test/java/org/graphwalker/dsl/GeneratorFactoryScannerTest.java

@@ -0,0 +1,13 @@
+package org.graphwalker.dsl;
+
+import org.graphwalker.dsl.antlr.generator.GeneratorFactoryScanner;
+import org.junit.Test;
+
+import static org.junit.Assert.assertNotNull;
+
+public class GeneratorFactoryScannerTest {
+  @Test
+  public void validPluginGenerator() {
+    assertNotNull(GeneratorFactoryScanner.get("PluginGenerator"));
+  }
+}

graphwalker-dsl/src/test/java/org/graphwalker/dsl/GeneratorFactoryTest.java

@@ -50,14 +50,17 @@
 import org.graphwalker.core.generator.WeightedRandomPath;
 import org.graphwalker.dsl.antlr.DslException;
 import org.graphwalker.dsl.antlr.generator.GeneratorFactory;
+import org.graphwalker.dsl.antlr.generator.GeneratorFactoryException;
+import org.graphwalker.generator.PluginGenerator;
+import org.junit.Assert;
 import org.junit.Test;
 
 /**
  * Created by krikar on 5/14/14.
  */
 public class GeneratorFactoryTest {
 
-  @Test(expected = DslException.class)
+  @Test(expected = GeneratorFactoryException.class)
   public void unvalidGenerator() {
     GeneratorFactory.parse("kskskdhfh(edge_coverage(100))");
   }
@@ -310,4 +313,15 @@ public void multipleAlternativeStopConditions() {
     assertThat(generator.getStopCondition(), instanceOf(AlternativeCondition.class));
     assertThat(((AlternativeCondition) generator.getStopCondition()).getStopConditions().size(), is(3));
   }
+
+  /**
+   * Tries to load a plugin generator that should be found in the classpath
+   */
+  @Test
+  public void plugin_generator() {
+    PathGenerator generator = GeneratorFactory.parse("pluginGenerator(edge_coverage(100))");
+    Assert.assertThat(generator, instanceOf(PluginGenerator.class));
+    Assert.assertThat(generator.getStopCondition(), instanceOf(EdgeCoverage.class));
+    Assert.assertThat(((EdgeCoverage) generator.getStopCondition()).getPercent(), is(100));
+  }
 }

graphwalker-dsl/src/test/java/org/graphwalker/generator/PluginGenerator.java

@@ -0,0 +1,47 @@
+package org.graphwalker.generator;
+
+import org.graphwalker.core.condition.StopCondition;
+import org.graphwalker.core.generator.NoPathFoundException;
+import org.graphwalker.core.generator.PathGeneratorBase;
+import org.graphwalker.core.machine.Context;
+import org.graphwalker.core.model.Element;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+import java.util.Random;
+
+/**
+ * A generator that is a code copy of the RandomPathGenerator.
+ * It serves the purpose of verifying the runtime loading of an plugin generator
+ */
+public class PluginGenerator extends PathGeneratorBase<StopCondition> {
+
+  private static final Logger LOG = LoggerFactory.getLogger(PluginGenerator.class);
+
+  private final Random random = new Random(System.nanoTime());
+
+  public PluginGenerator(StopCondition stopCondition) {
+    setStopCondition(stopCondition);
+  }
+
+  @Override
+  public Context getNextStep() {
+    Context context = super.getNextStep();
+    Element currentElement = context.getCurrentElement();
+    List<Element> elements = context.filter(context.getModel().getElements(currentElement));
+    if (elements.isEmpty()) {
+      LOG.error("currentElement: " + currentElement);
+      LOG.error("context.getModel().getElements(): " + context.getModel().getElements());
+      throw new NoPathFoundException(context.getCurrentElement());
+    }
+    context.setCurrentElement(elements.get(random.nextInt(elements.size())));
+    return context;
+  }
+
+  @Override
+  public boolean hasNextStep() {
+    return !getStopCondition().isFulfilled();
+  }
+
+}