reporting to images

.gitignore

@@ -21,3 +21,4 @@ spring-shell.log
 .idea/*
 *.log
 
+user/staging

acropolis-persistence/src/main/kotlin/org/ephyra/acropolis/persistence/api/persistence/GraphicalAssetPersistence.kt

@@ -30,4 +30,15 @@ class GraphicalAssetPersistence {
     fun findAll(): MutableIterable<GraphicalAssetEntity> {
         return repo.findAll()
     }
+
+    /**
+     * Find a graphical asset by name
+     *
+     * @param name The name of the asset
+     * @return the asset, if found
+     */
+    fun find(name: String): GraphicalAssetEntity? {
+        val asset = repo.findByName(name)
+        return if (asset.isPresent) asset.get() else null
+    }
 }

acropolis-persistence/src/main/kotlin/org/ephyra/acropolis/persistence/impl/GraphicalAssetRepository.kt

@@ -2,8 +2,17 @@ package org.ephyra.acropolis.persistence.impl
 
 import org.ephyra.acropolis.persistence.api.entity.GraphicalAssetEntity
 import org.springframework.data.repository.CrudRepository
+import java.util.Optional
 
 /**
  * Repository for storing graphical assets
  */
-interface GraphicalAssetRepository : CrudRepository<GraphicalAssetEntity, Long>
+interface GraphicalAssetRepository : CrudRepository<GraphicalAssetEntity, Long> {
+    /**
+     * Find a graphical asset by name
+     *
+     * @param name The name of the asset
+     * @return the asset, if found
+     */
+    fun findByName(name: String): Optional<GraphicalAssetEntity>
+}

acropolis-report/build.gradle

@@ -0,0 +1,69 @@
+buildscript {
+    ext {
+        kotlinVersion = "1.2.71"
+    }
+    repositories {
+        jcenter()
+    }
+    dependencies {
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlinVersion"
+        classpath "org.jetbrains.kotlin:kotlin-allopen:$kotlinVersion"
+    }
+}
+
+apply plugin: 'kotlin'
+apply plugin: 'jacoco'
+
+sourceCompatibility = 1.8
+compileKotlin {
+    kotlinOptions {
+        freeCompilerArgs = ["-Xjsr305=strict"]
+        jvmTarget = "1.8"
+    }
+}
+
+jacoco {
+    toolVersion = '0.8.2'
+}
+
+jacocoTestReport {
+    reports {
+        xml.enabled = true
+        html.enabled = true
+        csv.enabled = false
+    }
+}
+
+jacocoTestCoverageVerification {
+    violationRules {
+        rule {
+            limit {
+                minimum = 0.9
+            }
+        }
+    }
+}
+
+test {
+    useJUnitPlatform()
+}
+
+dependencies {
+    // The Kotlin standard library
+    compile "org.jetbrains.kotlin:kotlin-stdlib-jdk8"
+
+    // https://mvnrepository.com/artifact/org.slf4j/slf4j-api
+    compile group: 'org.slf4j', name: 'slf4j-api', version: '1.7.25'
+
+    // https://mvnrepository.com/artifact/org.springframework/spring-context
+    compile group: 'org.springframework', name: 'spring-context', version: '5.1.1.RELEASE'
+
+    // https://mvnrepository.com/artifact/ch.qos.logback/logback-classic
+    testCompile group: 'ch.qos.logback', name: 'logback-classic', version: '1.2.3'
+
+    // https://mvnrepository.com/artifact/io.kotlintest/kotlintest-runner-junit5
+    testCompile "io.kotlintest:kotlintest-runner-junit5:3.1.9"
+
+    // https://mvnrepository.com/artifact/io.mockk/mockk
+    testCompile "io.mockk:mockk:1.8.7"
+}

acropolis-report/src/main/kotlin/org/ephyra/acropolis/report/api/IImageSource.kt

@@ -0,0 +1,16 @@
+package org.ephyra.acropolis.report.api
+
+import java.io.InputStream
+
+/**
+ * Image source to provide images on request to the rendering process.
+ */
+interface IImageSource {
+    /**
+     * Get an image by its resource name
+     *
+     * @param resourceName The resource name of the image
+     * @return An input stream for the image data to be read from
+     */
+    fun get(resourceName: String): InputStream
+}

acropolis-report/src/main/kotlin/org/ephyra/acropolis/report/api/IReportRunner.kt

@@ -0,0 +1,16 @@
+package org.ephyra.acropolis.report.api
+
+import org.ephyra.acropolis.report.api.model.GraphContainer
+
+/**
+ * Interface for a report runner. This interface provides the entry point into this module.
+ */
+interface IReportRunner {
+    /**
+     * Run a report based on the provided model
+     *
+     * @param graphContainer The container for the model to build the report from
+     * @param imageSource Source to allow images to be provided during the rendering process
+     */
+    fun run(graphContainer: GraphContainer, imageSource: IImageSource)
+}

acropolis-report/src/main/kotlin/org/ephyra/acropolis/report/api/model/Graph.kt

@@ -0,0 +1,140 @@
+package org.ephyra.acropolis.report.api.model
+
+/**
+ * Container for a graph model.
+ * Allows metadata to be provided with the model.
+ */
+class GraphContainer(
+        val graph: Graph
+) {
+    private val subGraphs: MutableList<SubGraphSelector> = ArrayList()
+
+    /**
+     * Define a named sub-graph of the graph held by this container.
+     * The provided list of nodes can later be used to extract a sub-graph.
+     *
+     * @param name The name of the sub-graph
+     * @param includeNodes The nodes to include in the sub-graph
+     */
+    fun defineSubgraph(name: String, includeNodes: List<Node>) {
+        subGraphs.add(SubGraphSelector(name, includeNodes))
+    }
+}
+
+/**
+ * Model to represent a graph, in the mathematical sense.
+ */
+class Graph {
+    private val nodes: MutableSet<Node> = HashSet()
+
+    private val edges: MutableList<Edge> = ArrayList()
+
+    /**
+     * Add a node to the graph
+     *
+     * @param node The node to add
+     */
+    fun addNode(node: Node) {
+        nodes.add(node)
+    }
+
+    /**
+     * Add an edge between two nodes
+     *
+     * @param n1 Node to connect
+     * @param n2 Node to connect
+     */
+    fun addEdge(n1: Node, n2: Node) {
+        edges.add(Edge(n1, n2, false))
+    }
+
+    /**
+     * Add a directed edge between two nodes
+     *
+     * @param from The source node for the edge
+     * @param to The sink node for the edge
+     */
+    fun addDirectedEdge(from: Node, to: Node) {
+        edges.add(Edge(from, to, true))
+    }
+
+    /**
+     * Find a node by its label
+     *
+     * @param label The label to search for
+     * @return The node, if found
+     */
+    fun findNode(label: String): Node? {
+        return nodes.find { node -> node.label == label }
+    }
+
+    /**
+     * Find nodes, N, such that all edges which connect N to the graph, N is the source.
+     *
+     * Only valid for di-graphs, otherwise must allow edges if incoming edges have a corresponding outgoing edge.
+     */
+    fun findSourceNodes(): HashSet<Node> {
+        val tempNodes = HashSet<Node>()
+        tempNodes.addAll(nodes)
+
+        edges.forEach { edge ->
+            val node = edge.sink
+            tempNodes.remove(node)
+        }
+
+        return tempNodes
+    }
+
+    /**
+     * Return which ever node happens to be first.
+     *
+     * @return The first node in the graph, as it is stored
+     */
+    fun firstNode(): Node {
+        return nodes.first()
+    }
+
+    /**
+     * Finds edges such that the specified node is the source, and collects the set of sink nodes
+     * from these edges.
+     */
+    fun findNodesConnectedFrom(node: Node): HashSet<Node> {
+        val tempNodes = HashSet<Node>()
+        edges.forEach { edge ->
+            if (edge.source == node) {
+                tempNodes.add(edge.sink)
+            }
+        }
+
+        return tempNodes
+    }
+}
+
+/**
+ * Model to represent a node in a graph
+ */
+class Node(
+        val label: String,
+
+        val representedByResourceName: String
+)
+
+/**
+ * Model to represent an edge in a graph
+ */
+class Edge(
+        val source: Node,
+
+        val sink: Node,
+
+        val directed: Boolean = false
+)
+
+/**
+ * Selector for building a sub-graph from a subset of a graph's nodes.
+ */
+class SubGraphSelector (
+        val name: String,
+
+        val includeNodes: List<Node>
+)

acropolis-report/src/main/kotlin/org/ephyra/acropolis/report/config/ReportConfiguration.kt

@@ -0,0 +1,12 @@
+package org.ephyra.acropolis.report.config
+
+import org.springframework.context.annotation.ComponentScan
+import org.springframework.context.annotation.Configuration
+
+/**
+ * Configuration root for the module. By directing the Spring framework to load this class as configuration
+ * the entire module will be configured for use.
+ */
+@Configuration
+@ComponentScan(basePackages = ["org.ephyra.acropolis.report.config", "org.ephyra.acropolis.report.impl"])
+open class ReportConfiguration