Merge branch 'release/0.6.0'

Author: moaxcp

README.md

@@ -12,7 +12,7 @@ It is designed to be groovy, using closures and metaprogramming for minimal setu
 
 ```groovy
 #!/usr/bin/env groovy
-@Grab(group='com.github.moaxcp', module='graph-dsl', version='0.5.0')
+@Grab(group='com.github.moaxcp', module='graph-dsl', version='0.6.0')
 import static graph.Graph.graph
 
 graph {
@@ -86,6 +86,13 @@ Contributions are welcome. Please submit a pull request to the develop branch in
 
 # Releases
 
+## 0.6.0
+
+* fixed issue with logging when optimizations are turned off
+* updating gradle to 3.4.1
+* fixed many codenarc issues
+* added support for breadth first traversal
+
 ## 0.5.1
 
 * Added warning when optimizations are turned off

build.gradle

@@ -36,7 +36,7 @@ jacocoTestReport {
 gradle.taskGraph.whenReady { graph ->
     if (graph.hasTask(':jacocoTestReport') || graph.hasTask(':sonarqube')) {
         compileGroovy.groovyOptions.optimizationOptions.all = false
-        log.warn 'all groovy optimizations are turned off for jacoco'
+        logger.warn 'all groovy optimizations are turned off for jacoco'
     }
 }
 

gradle/wrapper/gradle-wrapper.jar

@@ -1,6 +1,6 @@
-#Sat Feb 04 14:13:34 EST 2017
+#Sat Mar 11 14:54:25 EST 2017
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-3.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-3.4.1-bin.zip

gradle/wrapper/gradle-wrapper.properties

@@ -0,0 +1,26 @@
+package graph
+
+/**
+ * Specification for a BreadFirstTraversal. Contains actions that are called
+ * when an event happens during the traversal.
+ */
+class BreadthFirstTraversalSpec extends TraversalSpec {
+    private Closure visitClosure
+
+    /**
+     * Returns the visit closure
+     * @return
+     */
+    Closure getVisit() {
+        visitClosure
+    }
+
+    /**
+     * sets the visit closure
+     * @param visitClosure
+     * @return
+     */
+    void visit(Closure visitClosure) {
+        this.visitClosure = visitClosure
+    }
+}

src/main/groovy/graph/BreadthFirstTraversalSpec.groovy

@@ -1,8 +1,12 @@
 package graph
 
+/**
+ * Factory for creating vertices. This factory returns instances of the
+ * base class Vertex.
+ */
 class DefaultVertexFactory implements VertexFactory {
     @Override
     Vertex newVertex(String name) {
-        return new Vertex(name: name)
+        new Vertex(name:name)
     }
 }

src/main/groovy/graph/DefaultVertexFactory.groovy

@@ -1,46 +1,44 @@
 package graph
 
 /**
- * Specification for a DepthFirstSearch. Contains actions that are called when and
- * even happens during the search.
+ * Specification for a DepthFirstTraversal. Contains actions that are called when an
+ * event happens during the traversal.
  */
-class DepthFirstTraversalSpec {
-    String root
-    Map colors
-    private Closure preorder
-    private Closure postorder
+class DepthFirstTraversalSpec extends TraversalSpec {
+    private Closure preorderClosure
+    private Closure postorderClosure
 
     /**
      * returns the preorder event.
      * @return
      */
-    def getPreorder() {
-        return preorder
+    Closure getPreorder() {
+        preorderClosure
     }
 
     /**
      * returns the postorder event.
      * @return
      */
-    def getPostorder() {
-        return postorder
+    Closure getPostorder() {
+        postorderClosure
     }
 
     /**
      * method to set the preorder event
-     * @param preorder
+     * @param preorderClosure
      * @return
      */
-    def preorder(Closure preorder) {
-        this.preorder = preorder
+    void preorder(Closure preorderClosure) {
+        this.preorderClosure = preorderClosure
     }
 
     /**
      * method to set the postorder event
-     * @param postorder
+     * @param postorderClosure
      * @return
      */
-    def postorder(Closure postorder) {
-        this.postorder = postorder
+    void postorder(Closure postorderClosure) {
+        this.postorderClosure = postorderClosure
     }
 }

src/main/groovy/graph/DepthFirstTraversalSpec.groovy

@@ -1,15 +1,27 @@
 package graph
 
+/**
+ * Represents a directed edge in a grpah. Since these should be soted in a
+ * Set the equals method is overridden to allow edges in both directions between
+ * two vertices.
+ */
+@SuppressWarnings('EqualsAndHashCode') //equals still meets contract with hashCode (I think)
 class DirectedEdge extends Edge {
 
-    public boolean equals(Object o) {
+    /**
+     * overridden to allow edges in both directions between two vertices.
+     * @param o
+     * @return true if two edges are equal.
+     */
+    @SuppressWarnings('Instanceof')
+    boolean equals(Object o) {
         if (!(o instanceof DirectedEdge)) {
             return false
         }
         if (this.is(o)) {
             return true
         }
-        DirectedEdge rhs = (DirectedEdge) o;
-        return one == rhs.one && two == rhs.two
+        DirectedEdge rhs = (DirectedEdge) o
+        one == rhs.one && two == rhs.two
     }
 }

src/main/groovy/graph/DirectedEdge.groovy

@@ -1,8 +1,19 @@
 package graph
 
+/**
+ * Factory for creating edges. This class returns instances of
+ * Directed Edge.
+ */
 class DirectedEdgeFactory implements EdgeFactory {
+
+    /**
+     * Returns a new DirectedEdge with the given parameters.
+     * @param one
+     * @param two
+     * @return a new DirectedEdge
+     */
     @Override
     Edge newEdge(String one, String two) {
-        return new DirectedEdge(one: one, two: two)
+        new DirectedEdge(one:one, two:two)
     }
 }

src/main/groovy/graph/DirectedEdgeFactory.groovy

@@ -1,10 +1,26 @@
 package graph
 
+/**
+ * This plugin makes a Graph behave like a directed graph.
+ */
 class DirectedGraphPlugin implements Plugin {
 
-    def apply(Graph graph) {
+    /**
+     * The following modifications are made to the graph:
+     *
+     * members
+     * edges - converted to DirectedEdges
+     * edgeFactory - changed to a DirectedEdgeFactory
+     *
+     * methods
+     * outEdges - returns out going edges from a given vertex name
+     * adjacentEdges - now only returns outgoing edges from the given vertex name
+     * @param graph
+     * @return
+     */
+    void apply(Graph graph) {
         graph.@edges = graph.@edges.collect { edge ->
-            new DirectedEdge(one: edge.one, two: edge.two)
+            new DirectedEdge(one:edge.one, two:edge.two)
         } as LinkedHashSet
 
         graph.edgeFactory = new DirectedEdgeFactory()