Add sample Groovy application

Author: Jegors Cemisovs

Diff for: .idea/gradle.xml

@@ -1,5 +1,5 @@
 plugins {
-//    id 'groovy'
+    id 'groovy'
     id 'java-library'
     id 'maven-publish'
 }

Diff for: algorithm/build.gradle

@@ -14,8 +14,22 @@
 @FunctionalInterface
 public interface Graph<T> {
     /**
-     * The schema of this graph.
+     * Creates a Graph object by given schema.
+     * <p>
+     * In a graph schema, each vertex is assigned an edge map.
+     * If the vertex has no edges, then it should be assigned an empty map.
      *
+     * @param schema of the graph
+     * @param <T>    the type of vertex in this graph
+     * @return graph object with given schema
+     */
+    static <T> Graph<T> of(Map<T, Map<T, Number>> schema) {
+        return () -> schema;
+    }
+
+    /**
+     * The schema of this graph.
+     * <p>
      * In a graph schema, each vertex is assigned an edge map.
      * If the vertex has no edges, then it should be assigned an empty map.
      *
@@ -54,18 +68,4 @@ default double getDistance(List<T> path) {
                 .mapToDouble(Number::doubleValue)
                 .sum();
     }
-
-    /**
-     * Creates a Graph object by given schema.
-     *
-     * In a graph schema, each vertex is assigned an edge map.
-     * If the vertex has no edges, then it should be assigned an empty map.
-     *
-     * @param schema of the graph
-     * @param <T>    the type of vertex in this graph
-     * @return graph object with given schema
-     */
-    static <T> Graph<T> of(Map<T, Map<T, Number>> schema) {
-        return () -> schema;
-    }
 }

Diff for: algorithm/src/main/java/lv/id/jc/algorithm/graph/Graph.java

@@ -5,16 +5,16 @@
 /**
  * A functional interface for graph search algorithm
  *
- * @author Jegors Čemisovs
  * @param <T> the type of vertex
+ * @author Jegors Čemisovs
  * @since 1.0
  */
 @FunctionalInterface
 public interface SearchAlgorithm<T> {
     /**
      * Find the path from the source node to the target
      *
-     * @param graph The graph in which we search for the path
+     * @param graph  The graph in which we search for the path
      * @param source Search starting point identifier
      * @param target Search finish point identifier
      * @return Path found or empty list if path cannot be found

Diff for: algorithm/src/main/java/lv/id/jc/algorithm/graph/SearchAlgorithm.java

@@ -1,5 +1,3 @@
-package lv.id.jc.graph
-
 import lv.id.jc.algorithm.graph.BreadthFirstSearch
 import lv.id.jc.algorithm.graph.Graph
 import spock.lang.*
@@ -14,20 +12,20 @@ class BreadthFirstSearchSpec extends Specification {
     def algorithm = new BreadthFirstSearch()
 
     def 'should find a route for simple graph'() {
-        given: 'A simple graph'
+        given:
         def graph = Graph.of([
                 A: [B: 7, C: 2],
                 B: [A: 3, C: 5],
                 C: [A: 1, B: 3]
         ])
 
-        when: 'we use Breadth First Search algorithm to find a path'
+        when:
         def path = algorithm.findPath(graph, source, target)
 
-        then: 'we get the shortest path'
+        then:
         path == shortest
 
-        and: 'the distance calculated correctly'
+        and:
         graph.getDistance(path) == time as double
 
         where:
@@ -39,7 +37,7 @@ class BreadthFirstSearchSpec extends Specification {
     }
 
     def 'should find a route for complex graph'() {
-        given: 'A complex graph'
+        given:
         def graph = Graph.of([
                 A: [B: 1],
                 B: [A: 1, D: 1],
@@ -48,13 +46,13 @@ class BreadthFirstSearchSpec extends Specification {
                 E: [F: 1],
                 F: [D: 1, E: 1]])
 
-        when: 'we use Breadth First Search algorithm to find a path'
+        when:
         def path = algorithm.findPath(graph, source, target)
 
-        then: 'we get the shortest path'
+        then:
         path == shortest
 
-        and: 'the distance calculated correctly'
+        and:
         graph.getDistance(path) == time as double
 
         where:
@@ -72,24 +70,24 @@ class BreadthFirstSearchSpec extends Specification {
     }
 
     def 'should thrown NPE path for an empty graph'() {
-        given: 'an empty graph'
+        given:
         def graph = Graph.of([:])
 
-        when: "we use Dijkstra's algorithm to find a path"
+        when:
         algorithm.findPath(graph, 'A', 'B')
 
-        then: 'the exception was thrown'
+        then:
         thrown NullPointerException
     }
 
     def "should return an empty path if can't find a route"() {
         given: 'a simple graph with no edge between nodes'
         def graph = Graph.of([A: [:], B: [:]])
 
-        when: 'we use Breadth First Search algorithm to find a path'
+        when:
         def path = algorithm.findPath(graph, 'A', 'B')
 
-        then: 'we get an empty path'
+        then:
         path == []
     }
 }

Diff for: algorithm/src/test/groovy/lv/id/jc/graph/BreadthFirstSearchSpec.groovy renamed to algorithm/src/test/groovy/BreadthFirstSearchSpec.groovy

@@ -1,5 +1,3 @@
-package lv.id.jc.graph
-
 import lv.id.jc.algorithm.graph.DijkstrasAlgorithm
 import lv.id.jc.algorithm.graph.Graph
 import spock.lang.*
@@ -12,20 +10,20 @@ class DijkstrasAlgorithmSpec extends Specification {
     def algorithm = new DijkstrasAlgorithm()
 
     def 'should find a route for a simple graph'() {
-        given: 'A simple graph'
+        given:
         def graph = Graph.of([
                 A: [B: 7, C: 2],
                 B: [A: 3, C: 5],
                 C: [A: 1, B: 3]
         ])
 
-        when: "we use Dijkstra's algorithm to find a path"
+        when:
         def path = algorithm.findPath(graph, source, target)
 
-        then: 'we get the fastest way'
+        then:
         path == fastest
 
-        and: 'the distance calculated correctly'
+        and:
         graph.getDistance(path) == time as double
 
         where:
@@ -37,7 +35,7 @@ class DijkstrasAlgorithmSpec extends Specification {
     }
 
     def 'should find a route for a medium graph'() {
-        given: 'A medium graph'
+        given:
         def graph = Graph.of([
                 A: [B: 5],
                 B: [A: 5, C: 10],
@@ -46,13 +44,13 @@ class DijkstrasAlgorithmSpec extends Specification {
                 E: [B: 5]
         ])
 
-        when: "we use Dijkstra's algorithm to find a path"
+        when:
         def path = algorithm.findPath(graph, source, target)
 
-        then: 'we get the fastest way'
+        then:
         path == fastest
 
-        and: 'the distance calculated correctly'
+        and:
         graph.getDistance(path) == time as double
 
         where:
@@ -66,7 +64,7 @@ class DijkstrasAlgorithmSpec extends Specification {
     }
 
     def 'should find a route for a complex graph'() {
-        given: 'A complex graph'
+        given:
         def graph = Graph.of([
                 A: [B: 5, H: 2],
                 B: [A: 5, C: 7],
@@ -78,13 +76,13 @@ class DijkstrasAlgorithmSpec extends Specification {
                 H: [G: 3]
         ])
 
-        when: "we use Dijkstra's algorithm to find a path"
+        when:
         def path = algorithm.findPath(graph, source, target)
 
-        then: 'we get the fastest way'
+        then:
         path == fastest
 
-        and: 'the distance calculated correctly'
+        and:
         graph.getDistance(path) == time as double
 
         where:
@@ -104,24 +102,24 @@ class DijkstrasAlgorithmSpec extends Specification {
     }
 
     def 'should thrown NPE for an empty graph'() {
-        given: 'an empty graph'
+        given:
         def graph = Graph.of([:])
 
-        when: "we use Dijkstra's algorithm to find a path"
+        when:
         algorithm.findPath(graph, 'A', 'B')
 
-        then: 'the exception was thrown'
+        then:
         thrown NullPointerException
     }
 
     def "should return an empty path if can't find a route"() {
         given: 'a simple graph with no edge between nodes'
         def graph = Graph.of([A: [:], B: [:]])
 
-        when: "we use Dijkstra's algorithm to find a path"
+        when:
         def path = algorithm.findPath(graph, 'A', 'B')
 
-        then: 'we get an empty path'
+        then:
         path == []
     }
 }

Diff for: algorithm/src/test/groovy/lv/id/jc/graph/DijkstrasAlgorithmSpec.groovy renamed to algorithm/src/test/groovy/DijkstrasAlgorithmSpec.groovy

@@ -1,5 +1,3 @@
-package lv.id.jc.graph
-
 import lv.id.jc.algorithm.graph.Graph
 import spock.lang.Narrative
 import spock.lang.Specification

Diff for: algorithm/src/test/groovy/lv/id/jc/graph/GraphSpec.groovy renamed to algorithm/src/test/groovy/GraphSpec.groovy

@@ -1,5 +1,3 @@
-package lv.id.jc.graph
-
 import lv.id.jc.algorithm.graph.BreadthFirstSearch
 import lv.id.jc.algorithm.graph.DijkstrasAlgorithm
 import lv.id.jc.algorithm.graph.Graph
@@ -16,7 +14,7 @@ class SearchAlgorithmSpec extends Specification {
     def dijkstras = new DijkstrasAlgorithm()
 
     def 'should find a route for a complex graph'() {
-        given: 'A complex graph sample'
+        given:
         def graph = Graph.of([
                 A: [B: 5, H: 2],
                 B: [A: 5, C: 7],
@@ -28,19 +26,19 @@ class SearchAlgorithmSpec extends Specification {
                 H: [G: 3]
         ])
 
-        when: 'we use Breadth First Search algorithm for the first route'
+        when:
         def routeOne = bfsAlgorithm.findPath(graph, source, target)
 
-        and: 'we use Dijkstras algorithm for the second route'
+        and:
         def routeTwo = dijkstras.findPath(graph, source, target)
 
-        then: "the first route is the shortest"
+        then:
         routeOne == shortest
 
-        and: 'the second route is the fastest'
+        and:
         routeTwo == fastest
 
-        and: 'the distance calculated correctly'
+        and:
         graph.getDistance(routeOne) == d1 as double
         graph.getDistance(routeTwo) == d2 as double
 

Diff for: algorithm/src/test/groovy/lv/id/jc/graph/SearchAlgorithmSpec.groovy renamed to algorithm/src/test/groovy/SearchAlgorithmSpec.groovy

@@ -0,0 +1,17 @@
+plugins {
+    id 'groovy'
+}
+
+java {
+    sourceCompatibility = JavaVersion.VERSION_17
+}
+
+repositories {
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'org.codehaus.groovy:groovy-all:3.0.8'
+    implementation project(':algorithm')
+}
+

Diff for: application/src/main/java/module-info.java

@@ -0,0 +1,43 @@
+package lv.id.jc.sample
+
+import lv.id.jc.algorithm.graph.BreadthFirstSearch
+import lv.id.jc.algorithm.graph.DijkstrasAlgorithm
+import lv.id.jc.algorithm.graph.Graph
+
+def complexGraph = Graph.of([
+        A: [B: 5, H: 2],
+        B: [A: 5, C: 7],
+        C: [B: 7, D: 3, G: 4],
+        D: [C: 20, E: 4],
+        E: [F: 5],
+        F: [G: 6],
+        G: [C: 4],
+        H: [G: 3]
+])
+
+def app = new SampleApp(complexGraph)
+
+app.printRoute('D', 'C');
+app.printRoute('A', 'G');
+app.printRoute('D', 'H');
+
+class SampleApp {
+    final fastest = new DijkstrasAlgorithm();
+    final shortest = new BreadthFirstSearch();
+    final graph
+
+    SampleApp(graph) {
+        this.graph = graph
+    }
+
+    def printRoute(source, target) {
+        var routeOne = shortest.findPath(graph, source, target);
+        var routeTwo = fastest.findPath(graph, source, target);
+
+        println """Find the path from $source to $target
+        - the shortest take ${graph.getDistance(routeOne)} min and the path is ${routeOne}
+        - the fastest take ${graph.getDistance(routeTwo)} min and the path is ${routeTwo}
+        """
+    }
+
+}