feat: support for ontology generation

fix: blank EntityId decoder

Author: jachro

README.md

@@ -181,3 +181,56 @@ Every JsonLD object can be turn to Json using it's `toJson` method.
 ## Detailed examples
 
 **For More examples, please see src/examples/scala/examples**
+
+## Ontology
+
+JsonLD4s library allows defining and generating ontologies.
+
+### Defining ontology
+
+Defining ontology of a specific type should be done using the `io.renku.jsonld.ontology.Type` class. An example definition can look like follows:
+
+```scala
+import io.renku.jsonld.ontology._
+import io.renku.jsonld.Schema
+
+val prov:   Schema = Schema.from("http://www.w3.org/ns/prov", separator = "#")
+val renku:  Schema = Schema.from("https://swissdatasciencecenter.github.io/renku-ontology", separator = "#")
+val schema: Schema = Schema.from("http://schema.org")
+
+val subtypeOntology: Type = Type.Def(
+  Class(schema / "Thing"),
+  DataProperty(schema / "name", xsd / "string")
+)
+
+val rootOntology: Type = Type.Def(
+  Class(prov / "Activity"),
+  ObjectProperties(
+    ObjectProperty(renku / "parameter", subtypeOntology)
+  ),
+  DataProperties(DataProperty(prov / "startedAtTime", xsd / "dateTime"),
+                 DataProperty(prov / "endedAtTime", xsd / "dateTime")
+  )
+)
+```
+
+Type's class needs to be defined with the `Class` type, properties linking other types with a collection of `ObjectProperty` objects and simple value properties with a collection of `DataProperty` objects. The library calculates properties' ranges and domains automatically during ontology generation.
+
+### Generating ontology
+
+Generating ontology is a trivial task which can be done using the `io.renku.jsonld.ontology.generateOntology` method. The method takes a `Type` definition and a `Schema`.
+
+```scala
+import io.renku.jsonld.ontology._
+import io.renku.jsonld.Schema
+
+val renku:  Schema = Schema.from("https://swissdatasciencecenter.github.io/renku-ontology", separator = "#")
+val schema: Schema = Schema.from("http://schema.org")
+
+val ontology: Type = Type.Def(
+  Class(schema / "Thing"),
+  DataProperty(schema / "name", xsd / "string")
+)
+
+generateOntology(ontology, renku)
+```

src/main/scala/io/renku/jsonld/EntityId.scala

@@ -56,13 +56,14 @@ object EntityId {
 
   implicit val entityIdJsonDecoder: Decoder[EntityId] = Decoder.instance {
     _.as[String].map {
-      case s if s.startsWith("_:") => EntityId.blank
-      case s                       => EntityId.of(s)
+      case s"_:${uuid}" => EntityId.BlankNodeEntityId(UUID.fromString(uuid))
+      case s            => EntityId.of(s)
     }
   }
 
   implicit val stringToEntityId:   String => EntityId   = v => StandardEntityId(URIref.encode(v))
   implicit val propertyToEntityId: Property => EntityId = p => StandardEntityId(URIref.encode(p.url))
+  implicit val schemaToEntityId:   Schema => EntityId   = s => StandardEntityId(URIref.encode(s.url))
 
   implicit val show: Show[EntityId] = Show[EntityId](entityId => entityId.valueShow.show(entityId.value))
 }

src/main/scala/io/renku/jsonld/JsonLDEncoder.scala

@@ -61,6 +61,7 @@ object JsonLDEncoder {
   final implicit val encodeLong:      JsonLDEncoder[Long]      = (a: Long) => JsonLD.fromLong(a)
   final implicit val encodeInstant:   JsonLDEncoder[Instant]   = (a: Instant) => JsonLD.fromInstant(a)
   final implicit val encodeLocalDate: JsonLDEncoder[LocalDate] = (a: LocalDate) => JsonLD.fromLocalDate(a)
+  final implicit val encodeSchema:    JsonLDEncoder[Schema]    = (a: Schema) => JsonLD.fromEntityId(a.toString)
   final implicit val encodeEntityId:  JsonLDEncoder[EntityId]  = JsonLD.fromEntityId
   final implicit val encodeJsonLD:    JsonLDEncoder[JsonLD]    = identity
   final implicit val encodeBoolean:   JsonLDEncoder[Boolean]   = (a: Boolean) => JsonLD.fromBoolean(a)

src/main/scala/io/renku/jsonld/Schema.scala

@@ -20,7 +20,7 @@ package io.renku.jsonld
 
 import cats.Show
 
-abstract class Schema(url: String, separator: String) extends Product with Serializable {
+abstract class Schema(val url: String, val separator: String) extends Product with Serializable {
   def /(name: String):        Property = Property(s"$url$separator$name")
   def /(name: Number):        Property = Property(s"$url$separator$name")
   def asPrefix(name: String): String   = s"PREFIX $name: <$url$separator>"
@@ -42,6 +42,6 @@ object Schema {
   def from(baseUrl: String, separator: String): Schema = CustomSeparatorSchema(baseUrl, separator)
 
   private[jsonld] final case class SlashSeparatorSchema(value: String) extends Schema(value, separator = "/")
-  private[jsonld] final case class CustomSeparatorSchema(value: String, separator: String)
+  private[jsonld] final case class CustomSeparatorSchema(value: String, override val separator: String)
       extends Schema(value, separator)
 }