Refactor URI responsibility onto Container and Var interfaces

simonoakesepimorphics · simonoakesepimorphics · commit e08a5d5dcb7f · 2021-02-02T09:51:34.000Z
diff --git a/binary-array-ld-lib/src/main/kotlin/net/bald/AttributeSource.kt b/binary-array-ld-lib/src/main/kotlin/net/bald/AttributeSource.kt
@@ -1,5 +1,7 @@
 package net.bald
 
+import org.apache.jena.shared.PrefixMapping
+
 /**
  * An entity which is described by its [Attribute]s.
  */
@@ -9,5 +11,5 @@ interface AttributeSource {
      * @param prefixMapping The prefix mapping to use to expand compact URIs.
      * @return The list of attributes.
      */
-    fun attributes(prefixMapping: org.apache.jena.shared.PrefixMapping): List<Attribute>
+    fun attributes(prefixMapping: PrefixMapping): List<Attribute>
 }
diff --git a/binary-array-ld-lib/src/main/kotlin/net/bald/Container.kt b/binary-array-ld-lib/src/main/kotlin/net/bald/Container.kt
@@ -6,10 +6,9 @@ package net.bald
  */
 interface Container: AttributeSource {
     /**
-     * The local name of the container, if it has one.
-     * The root container may have no name or an empty name.
+     * The URI of the container.
      */
-    val name: String?
+    val uri: String
 
     /**
      * Obtain the variables associates with this container.
diff --git a/binary-array-ld-lib/src/main/kotlin/net/bald/Var.kt b/binary-array-ld-lib/src/main/kotlin/net/bald/Var.kt
@@ -5,7 +5,7 @@ package net.bald
  */
 interface Var: AttributeSource {
     /**
-     * The local name of the variable.
+     * The URI of the variable.
      */
-    val name: String
+    val uri: String
 }
diff --git a/binary-array-ld-lib/src/main/kotlin/net/bald/alias/AliasContainer.kt b/binary-array-ld-lib/src/main/kotlin/net/bald/alias/AliasContainer.kt
@@ -10,7 +10,7 @@ class AliasContainer(
     private val container: Container,
     private val alias: AliasDefinition
 ): AliasAttributeSource(container, alias), Container {
-    override val name: String? get() = container.name
+    override val uri: String get() = container.uri
 
     override fun vars(): Sequence<Var> {
         return container.vars().map { v ->
diff --git a/binary-array-ld-lib/src/main/kotlin/net/bald/alias/AliasVar.kt b/binary-array-ld-lib/src/main/kotlin/net/bald/alias/AliasVar.kt
@@ -9,5 +9,5 @@ class AliasVar(
     private val v: Var,
     alias: AliasDefinition
 ): AliasAttributeSource(v, alias), Var {
-    override val name: String get() = v.name
+    override val uri: String get() = v.uri
 }
diff --git a/binary-array-ld-lib/src/main/kotlin/net/bald/model/ModelContainerBuilder.kt b/binary-array-ld-lib/src/main/kotlin/net/bald/model/ModelContainerBuilder.kt
@@ -11,8 +11,7 @@ open class ModelContainerBuilder(
     private val attrFct: ModelAttributeBuilder.Factory
 ) {
     open fun addContainer(container: Container) {
-        val containerUri = parent.withTrailingSlash() + (container.name ?: "")
-        val containerRes = parent.model.createResource(containerUri, BALD.Container)
+        val containerRes = parent.model.createResource(container.uri, BALD.Container)
         addSubContainers(container, containerRes)
         addVars(container, containerRes)
         addAttributes(container, containerRes)
diff --git a/binary-array-ld-lib/src/main/kotlin/net/bald/model/ModelVarBuilder.kt b/binary-array-ld-lib/src/main/kotlin/net/bald/model/ModelVarBuilder.kt
@@ -10,8 +10,7 @@ open class ModelVarBuilder(
     private val attrFct: ModelAttributeBuilder.Factory
 ) {
     open fun addVar(v: Var) {
-        val varUri = container.withTrailingSlash() + v.name
-        val vRes = container.model.createResource(varUri, BALD.Resource)
+        val vRes = container.model.createResource(v.uri, BALD.Resource)
         container.addProperty(BALD.contains, vRes)
         addAttributes(v, vRes)
     }
diff --git a/binary-array-ld-lib/src/test/kotlin/net/bald/model/ModelBinaryArrayConverterTest.kt b/binary-array-ld-lib/src/test/kotlin/net/bald/model/ModelBinaryArrayConverterTest.kt
@@ -23,16 +23,18 @@ class ModelBinaryArrayConverterTest {
         return ModelBinaryArrayConverter.convert(ba)
     }
 
-    private fun newVar(name: String): Var {
+    private fun newVar(uri: String): Var {
         return mock {
-            on { this.name } doReturn name
+            on { this.uri } doReturn uri
         }
     }
 
     @Test
     fun convert_returnsModel() {
-        val vars = listOf(newVar("foo"), newVar("bar"), newVar("baz"))
+        val uri = "http://test.binary-array-ld.net/example"
+        val vars = listOf(newVar("$uri/foo"), newVar("$uri/bar"), newVar("$uri/baz"))
         val root = mock<Container> {
+            on { this.uri } doReturn "$uri/"
             on { vars() } doReturn vars.asSequence()
             on { subContainers() } doReturn emptySequence()
         }
@@ -41,7 +43,7 @@ class ModelBinaryArrayConverterTest {
             .setNsPrefix("skos", SKOS.uri)
             .setNsPrefix("dct", DCTerms.NS)
         val ba = mock<BinaryArray> {
-            on { uri } doReturn "http://test.binary-array-ld.net/example"
+            on { this.uri } doReturn uri
             on { this.root } doReturn root
             on { prefixMapping } doReturn prefix
         }
diff --git a/binary-array-ld-lib/src/test/kotlin/net/bald/model/ModelContainerBuilderTest.kt b/binary-array-ld-lib/src/test/kotlin/net/bald/model/ModelContainerBuilderTest.kt
@@ -30,6 +30,7 @@ class ModelContainerBuilderTest {
     private val vars = listOf<Var>(mock(), mock(), mock())
     private val attrs = listOf<Attribute>(mock(), mock(), mock())
     private val container = mock<Container> {
+        on { uri } doReturn "http://test.binary-array-ld.net/example/foo"
         on { vars() } doReturn vars.asSequence()
         on { attributes(any()) } doReturn attrs
         on { subContainers() } doReturn emptySequence()
@@ -39,7 +40,7 @@ class ModelContainerBuilderTest {
     fun addContainer_addsContainerToModel() {
         builder.addContainer(container)
         ResourceVerifier(parent).statements {
-            statement(BALD.contains, model.createResource("${parent.uri}/")) {
+            statement(BALD.contains, model.createResource("${parent.uri}/foo")) {
                 statement(RDF.type, BALD.Container)
             }
         }
@@ -48,7 +49,7 @@ class ModelContainerBuilderTest {
     @Test
     fun addContainer_addsVars() {
         builder.addContainer(container)
-        verify(varFct).forContainer(model.createResource("${parent.uri}/"))
+        verify(varFct).forContainer(model.createResource("${parent.uri}/foo"))
         verify(varBuilder).addVar(vars[0])
         verify(varBuilder).addVar(vars[1])
         verify(varBuilder).addVar(vars[2])
@@ -58,24 +59,9 @@ class ModelContainerBuilderTest {
     fun addContainer_addsAttributes() {
         builder.addContainer(container)
         verify(container).attributes(model)
-        verify(attrFct).forResource(model.createResource("${parent.uri}/"))
+        verify(attrFct).forResource(model.createResource("${parent.uri}/foo"))
         verify(attrBuilder).addAttribute(attrs[0])
         verify(attrBuilder).addAttribute(attrs[1])
         verify(attrBuilder).addAttribute(attrs[2])
     }
-
-    @Test
-    fun addContainer_parentWithTrailingSlash_addsContainerToModel() {
-        val parent = model.createResource("http://test.binary-array-ld.net/example/")
-        container.stub {
-            on { name } doReturn "foo"
-        }
-
-        ModelContainerBuilder.Factory(varFct, attrFct).forParent(parent).addContainer(container)
-        ResourceVerifier(parent).statements {
-            statement(BALD.contains, model.createResource("${parent.uri}foo")) {
-                statement(RDF.type, BALD.Container)
-            }
-        }
-    }
 }
diff --git a/binary-array-ld-lib/src/test/kotlin/net/bald/model/ModelVarBuilderTest.kt b/binary-array-ld-lib/src/test/kotlin/net/bald/model/ModelVarBuilderTest.kt
@@ -22,16 +22,16 @@ class ModelVarBuilderTest {
     }
     private val builder = ModelVarBuilder.Factory(attrFct).forContainer(container)
 
-    private fun newVar(name: String, attrs: List<Attribute> = emptyList()): Var {
+    private fun newVar(uri: String, attrs: List<Attribute> = emptyList()): Var {
         return mock {
-            on { this.name } doReturn name
+            on { this.uri } doReturn uri
             on { attributes(any()) } doReturn attrs
         }
     }
 
     @Test
     fun addVar_addsResourceToContainer() {
-        val v = newVar("foo")
+        val v = newVar("http://test.binary-array-ld.net/example/foo")
         builder.addVar(v)
 
         ResourceVerifier(container).statements {
@@ -43,9 +43,9 @@ class ModelVarBuilderTest {
 
     @Test
     fun addVar_multiple_addsResourcesToContainer() {
-        val v1 = newVar("foo")
-        val v2 = newVar("bar")
-        val v3 = newVar("baz")
+        val v1 = newVar("http://test.binary-array-ld.net/example/foo")
+        val v2 = newVar("http://test.binary-array-ld.net/example/bar")
+        val v3 = newVar("http://test.binary-array-ld.net/example/baz")
 
         builder.addVar(v1)
         builder.addVar(v2)
@@ -68,7 +68,7 @@ class ModelVarBuilderTest {
     fun addVar_containerWithoutTrailingSlash_addsResourceToContainer() {
         val container = model.createResource("http://test.binary-array-ld.net/example")
 
-        val v = mock<Var> { on { name } doReturn "foo" }
+        val v = mock<Var> { on { uri } doReturn "http://test.binary-array-ld.net/example/foo" }
         ModelVarBuilder.Factory(attrFct).forContainer(container).addVar(v)
 
         ResourceVerifier(container).statements {
@@ -84,7 +84,7 @@ class ModelVarBuilderTest {
             mock { on { name } doReturn "type" },
             mock { on { name } doReturn "label" }
         )
-        val v = newVar("foo", attrs)
+        val v = newVar("http://test.binary-array-ld.net/example/foo", attrs)
         builder.addVar(v)
 
         verify(v).attributes(model)
diff --git a/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfBinaryArray.kt b/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfBinaryArray.kt
@@ -19,14 +19,14 @@ class NetCdfBinaryArray(
 ): BinaryArray {
     override val root: Container get() = container(file.rootGroup)
     override val prefixMapping: PrefixMapping get() = prefixMapping() ?: PrefixMapping.Factory.create()
+    val prefixSrc: String? get() = prefixSourceName()
 
     override fun close() {
         file.close()
     }
 
     private fun container(group: Group): Container {
-        val prefixSrc = prefixSourceName()
-        return NetCdfContainer(group, prefixSrc)
+        return NetCdfRootContainer(this, group)
     }
 
     private fun prefixMapping(): PrefixMapping? {
diff --git a/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfContainer.kt b/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfContainer.kt
@@ -9,31 +9,41 @@ import ucar.nc2.Variable
 
 /**
  * NetCDF implementation of [Container].
+ * See [NetCdfRootContainer] for the root group representation,
+ * and [NetCdfSubContainer] for sub-groups.
  */
-class NetCdfContainer(
-    private val group: Group,
-    private val prefixSrc: String? = null
+abstract class NetCdfContainer(
+    private val group: Group
 ): Container {
-    override val name: String? get() = group.shortName
 
     override fun vars(): Sequence<Var> {
-        return group.variables.asSequence().filter(::acceptVar).map(::NetCdfVar)
+        return group.variables.asSequence().filter(::acceptVar).map(::toVar)
     }
 
     override fun subContainers(): Sequence<Container> {
-        return group.groups.asSequence().filter(::acceptGroup).map(::NetCdfContainer)
+        return group.groups.asSequence().filter(::acceptGroup).map(::subContainer)
     }
 
-    private fun acceptVar(v: Variable): Boolean {
-        return prefixSrc != v.shortName
+    private fun toVar(v: Variable): Var {
+        return NetCdfVar(this, v)
     }
 
-    private fun acceptGroup(group: Group): Boolean {
-        return prefixSrc != group.shortName
+    private fun subContainer(group: Group): Container {
+        return NetCdfSubContainer(this, group)
+    }
+
+    open fun acceptVar(v: Variable): Boolean {
+        return true
+    }
+
+    open fun acceptGroup(group: Group): Boolean {
+        return true
     }
 
     override fun attributes(prefixMapping: PrefixMapping): List<Attribute> {
         val source = group.attributes().let(::NetCdfAttributeSource)
         return source.attributes(prefixMapping)
     }
-}
+
+    abstract fun childUri(name: String): String
+}
diff --git a/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfRootContainer.kt b/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfRootContainer.kt
@@ -0,0 +1,29 @@
+package net.bald.netcdf
+
+import ucar.nc2.Group
+import ucar.nc2.Variable
+import net.bald.Container
+
+/**
+ * NetCDF implementation of [Container] based on the root group.
+ */
+class NetCdfRootContainer(
+    private val ba: NetCdfBinaryArray,
+    group: Group,
+): NetCdfContainer(group) {
+    override val uri: String get() = ba.uri + "/" // TODO trailing slash???
+
+    private val prefixSrc = ba.prefixSrc
+
+    override fun acceptGroup(group: Group): Boolean {
+        return prefixSrc != group.shortName
+    }
+
+    override fun acceptVar(v: Variable): Boolean {
+        return prefixSrc != v.shortName
+    }
+
+    override fun childUri(name: String): String {
+        return uri + name
+    }
+}
diff --git a/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfSubContainer.kt b/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfSubContainer.kt
@@ -0,0 +1,18 @@
+package net.bald.netcdf
+
+import net.bald.Container
+import ucar.nc2.Group
+
+/**
+ * NetCDF implementation of [Container] based on a named sub-group.
+ */
+class NetCdfSubContainer(
+    private val parent: NetCdfContainer,
+    private val group: Group
+): NetCdfContainer(group) {
+    override val uri: String get() = parent.childUri(group.shortName)
+
+    override fun childUri(name: String): String {
+        return "$uri/$name"
+    }
+}
diff --git a/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfVar.kt b/binary-array-ld-netcdf/src/main/kotlin/net/bald/netcdf/NetCdfVar.kt
@@ -9,9 +9,10 @@ import ucar.nc2.Variable
  * NetCDF implementation of [Var].
  */
 class NetCdfVar(
+    private val parent: NetCdfContainer,
     private val v: Variable
 ): Var {
-    override val name: String get() = v.shortName
+    override val uri: String get() = parent.childUri(v.shortName)
 
     override fun attributes(prefixMapping: PrefixMapping): List<Attribute> {
         val source = v.attributes().let(::NetCdfAttributeSource)
diff --git a/binary-array-ld-netcdf/src/test/kotlin/net/bald/netcdf/NetCdfBinaryArrayTest.kt b/binary-array-ld-netcdf/src/test/kotlin/net/bald/netcdf/NetCdfBinaryArrayTest.kt

Original file line number	Diff line number	Diff line change
`@@ -9,5 +9,5 @@ class AliasVar(`
`9`	`9`	`private val v: Var,`
`10`	`10`	`alias: AliasDefinition`
`11`	`11`	`): AliasAttributeSource(v, alias), Var {`
`12`		`- override val name: String get() = v.name`
	`12`	`+ override val uri: String get() = v.uri`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -23,16 +23,18 @@ class ModelBinaryArrayConverterTest {`
`23`	`23`	`return ModelBinaryArrayConverter.convert(ba)`
`24`	`24`	`}`
`25`	`25`
`26`		`- private fun newVar(name: String): Var {`
	`26`	`+ private fun newVar(uri: String): Var {`
`27`	`27`	`return mock {`
`28`		`- on { this.name } doReturn name`
	`28`	`+ on { this.uri } doReturn uri`
`29`	`29`	`}`
`30`	`30`	`}`
`31`	`31`
`32`	`32`	`@Test`
`33`	`33`	`fun convert_returnsModel() {`
`34`		`- val vars = listOf(newVar("foo"), newVar("bar"), newVar("baz"))`
	`34`	`+ val uri = "http://test.binary-array-ld.net/example"`
	`35`	`+ val vars = listOf(newVar("$uri/foo"), newVar("$uri/bar"), newVar("$uri/baz"))`
`35`	`36`	`val root = mock<Container> {`
	`37`	`+ on { this.uri } doReturn "$uri/"`
`36`	`38`	`on { vars() } doReturn vars.asSequence()`
`37`	`39`	`on { subContainers() } doReturn emptySequence()`
`38`	`40`	`}`
`@@ -41,7 +43,7 @@ class ModelBinaryArrayConverterTest {`
`41`	`43`	`.setNsPrefix("skos", SKOS.uri)`
`42`	`44`	`.setNsPrefix("dct", DCTerms.NS)`
`43`	`45`	`val ba = mock<BinaryArray> {`
`44`		`- on { uri } doReturn "http://test.binary-array-ld.net/example"`
	`46`	`+ on { this.uri } doReturn uri`
`45`	`47`	`on { this.root } doReturn root`
`46`	`48`	`on { prefixMapping } doReturn prefix`
`47`	`49`	`}`