Mapping suggestion

build.sbt

@@ -107,7 +107,7 @@ lazy val core = (project in file("silk-core"))
   .settings(commonSettings: _*)
   .settings(
     name := "Silk Core",
-    libraryDependencies += "com.typesafe" % "config" % "1.4.2", // Should always use the same version as the Play Framework dependency
+    libraryDependencies += "com.typesafe" % "config" % "1.4.3", // Should always use the same version as the Play Framework dependency
     // Additional scala standard libraries
     libraryDependencies += "org.scala-lang.modules" %% "scala-xml" % "2.2.0",
     libraryDependencies += "org.scala-lang" % "scala-reflect" % scalaVersion.value,
@@ -207,7 +207,7 @@ lazy val serializationJson = (project in file("silk-plugins/silk-serialization-j
   .settings(
     name := "Silk Serialization JSON",
     libraryDependencies += "com.typesafe.play" %% "play-json" % "2.10.6",
-    libraryDependencies += "io.swagger.core.v3" % "swagger-annotations" % "2.2.23"
+    libraryDependencies += "io.swagger.core.v3" % "swagger-annotations" % "2.2.27"
   )
 
 lazy val persistentCaching = (project in file("silk-plugins/silk-persistent-caching"))
@@ -396,9 +396,9 @@ lazy val workbenchOpenApi = (project in file("silk-workbench/silk-workbench-open
   .settings(
     name := "Silk Workbench OpenAPI",
     libraryDependencies += "io.kinoplan" %% "swagger-play" % "0.0.5" exclude("org.scala-lang.modules", "scala-java8-compat_2.13") ,
-    libraryDependencies += "io.swagger.parser.v3" % "swagger-parser-v3" % "2.1.22",
-    libraryDependencies += "com.networknt" % "json-schema-validator" % "1.0.78",
-    libraryDependencies += "org.webjars" % "swagger-ui" % "5.17.14"
+    libraryDependencies += "io.swagger.parser.v3" % "swagger-parser-v3" % "2.1.24",
+    libraryDependencies += "com.networknt" % "json-schema-validator" % "1.5.4",
+    libraryDependencies += "org.webjars" % "swagger-ui" % "5.18.2"
   )
 
 lazy val workbench = (project in file("silk-workbench"))
@@ -427,7 +427,7 @@ lazy val singlemachine = (project in file("silk-tools/silk-singlemachine"))
   .settings(commonSettings: _*)
   .settings(
     name := "Silk SingleMachine",
-    libraryDependencies += "org.slf4j" % "slf4j-jdk14" % "2.0.5"
+    libraryDependencies += "org.slf4j" % "slf4j-jdk14" % "2.0.16"
   )
 
 //lazy val mapreduce = (project in file("silk-tools/silk-mapreduce"))

project/build.properties

@@ -1 +1 @@
-sbt.version=1.10.5
+sbt.version=1.10.7

project/plugins.sbt

@@ -1,5 +1,5 @@
 // The Play plugin
-addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.9.5")
+addSbtPlugin("com.typesafe.play" % "sbt-plugin" % "2.9.6")
 
 addSbtPlugin("com.eed3si9n" % "sbt-assembly" % "2.1.5")
 

silk-core/src/main/scala/org/silkframework/config/ConfigValue.scala

@@ -48,13 +48,13 @@ abstract class ConfigValue[T]() {
   * @tparam CLASS The class that holds the configuration.
   * @tparam T The configuration value type.
   */
-abstract class ClassConfigValue[CLASS: ClassTag, T]() extends ConfigValue[T] {
+abstract class ClassConfigValue[T: ClassTag]() extends ConfigValue[T] {
 
   /**
     * Retrieves the configuration for the given class.
     */
   protected override def config: TypesafeConfig = {
-    DefaultConfig.instance.forClass(implicitly[ClassTag[CLASS]].runtimeClass)
+    DefaultConfig.instance.forClass(implicitly[ClassTag[T]].runtimeClass)
   }
 
 }

silk-core/src/main/scala/org/silkframework/entity/paths/Path.scala

@@ -13,6 +13,10 @@ trait Path extends Serializable {
     */
   def operators: List[PathOperator]
 
+  /**
+   * Returns a copy with updated operators.
+   */
+  def withOperators(newOperators: List[PathOperator]): Path
 
   /**
     * The normalized serialization using the Silk RDF path language.

silk-core/src/main/scala/org/silkframework/entity/paths/PathWithMetadata.scala

@@ -33,6 +33,10 @@ class PathWithMetadata (
     */
   def getOriginalName: String = metadata(PathWithMetadata.META_FIELD_ORIGIN_NAME).toString
 
+  override def withOperators(newOperators: List[PathOperator]): PathWithMetadata = {
+    new PathWithMetadata(newOperators, valueType, metadata)
+  }
+
 }
 
 object PathWithMetadata{

silk-core/src/main/scala/org/silkframework/entity/paths/TypedPath.scala

@@ -69,6 +69,10 @@ case class TypedPath(
   }
 
   override def toString: String = s"$normalizedSerialization (${valueType.label})"
+
+  override def withOperators(newOperators: List[PathOperator]): TypedPath = {
+    copy(operators = newOperators)
+  }
 }
 
 object TypedPath {

silk-core/src/main/scala/org/silkframework/entity/paths/UntypedPath.scala

@@ -52,6 +52,10 @@ class UntypedPath private[entity](val operators: List[PathOperator]) extends Pat
 
   /** Returns an untyped ([[org.silkframework.entity.UntypedValueType]]) [[TypedPath]].  */
   def asUntypedValueType: TypedPath = TypedPath(this.operators, ValueType.UNTYPED, isAttribute = false)
+
+  override def withOperators(newOperators: List[PathOperator]): UntypedPath = {
+    new UntypedPath(operators = newOperators)
+  }
 }
 
 object UntypedPath {

silk-core/src/main/scala/org/silkframework/util/Identifier.scala

@@ -63,6 +63,8 @@ object Identifier {
     (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || (c >= '0' && c <= '9') || (c == '_') || (c == '-')
   }
 
+  def filterAllowedChars(str: String): String = str.filter(Identifier.isAllowed)
+
   /**
     * Creates a new Identifier only from the allowed characters in a given string.
     *
@@ -71,7 +73,7 @@ object Identifier {
     */
   def fromAllowed(str: String, alternative: Option[String] = None): Identifier = {
     try {
-      new Identifier(str.filter(Identifier.isAllowed))
+      new Identifier(filterAllowedChars(str))
     }  catch {
       case _: IllegalArgumentException if alternative.isDefined =>
         Identifier(alternative.get)

silk-core/src/main/scala/org/silkframework/util/IdentifierGenerator.scala

@@ -2,40 +2,49 @@ package org.silkframework.util
 
 /**
   * Generates identifiers that are unique in its scope.
+ *  Thread-safe.
   */
-class IdentifierGenerator(prefix: String = "") {
+class IdentifierGenerator {
 
   /**
-    * Remembers all existing identifiers and their counts.
-    */
-  private var identifiers = Map[String, Int]()
+   * Remembers all existing identifiers.
+   */
+  private var identifiers = Set[Identifier]()
+  // Default identifier if the desired ID contains no allowed characters.
+  final val UNNAMED_ID = "unnamed_id"
 
   /**
     * Generates a new unique identifier.
+   *
+   * @param desiredId The desired identifier. Invalid characters will be removed, so it's not required that this is a valid identifier.
+   * @return If the provided identifier is already unique, it will be returned unchanged. Otherwise, a unique identifier is generated by appending a number.
     */
-  def generate(identifier: String): Identifier = synchronized {
-    val (name, num) = split(Identifier.fromAllowed(prefix + identifier))
-    identifiers.get(name) match {
-      case Some(count) =>
-        identifiers += ((name, count + 1))
-        name + count.toString
-      case None =>
-        identifiers += ((name, 1))
-        name
+  def generate(desiredId: String): Identifier = synchronized {
+    val desiredIdOnlyAllowedChars = Identifier.filterAllowedChars(desiredId)
+    val identifier = Identifier(if(desiredIdOnlyAllowedChars.isEmpty) UNNAMED_ID else desiredIdOnlyAllowedChars)
+    if(!identifiers.contains(identifier)) {
+      // Identifier is already unique
+      identifiers += identifier
+      identifier
+    } else {
+      // Generate a new identifier by adding a unique number
+      val (name, num) = split(identifier)
+      for(i <- Iterator.from(num + 1)) {
+        val newIdentifier = name + i
+        if(!identifiers.contains(newIdentifier)) {
+          identifiers += newIdentifier
+          return newIdentifier
+        }
+      }
+      throw new IllegalStateException()
     }
   }
 
   /**
     * Adds an existing identifier without changing it.
     */
   def add(identifier: Identifier): Unit = synchronized {
-    val (name, num) = split(identifier)
-    identifiers.get(name.toString) match {
-      case Some(count) =>
-        identifiers += ((name, math.max(count, num + 1)))
-      case None =>
-        identifiers += ((name, num + 1))
-    }
+    identifiers += identifier
   }
 
   /**
@@ -51,3 +60,14 @@ class IdentifierGenerator(prefix: String = "") {
   }
 
 }
+
+/**
+ * Adds a prefix to all generated identifiers.
+ */
+class PrefixedIdentifierGenerator(prefix: String) extends IdentifierGenerator {
+
+  override def generate(desiredId: String): Identifier = {
+    super.generate(prefix + desiredId)
+  }
+
+}

silk-core/src/main/scala/org/silkframework/workspace/WorkspaceProvider.scala

@@ -1,7 +1,7 @@
 package org.silkframework.workspace
 
 import org.silkframework.config._
-import org.silkframework.dataset.rdf.SparqlEndpoint
+import org.silkframework.dataset.rdf.{GraphStoreTrait, SparqlEndpoint}
 import org.silkframework.runtime.activity.UserContext
 import org.silkframework.runtime.plugin.annotations.PluginType
 import org.silkframework.runtime.plugin.{AnyPlugin, ParameterValues, PluginContext}
@@ -16,7 +16,7 @@ import scala.collection.mutable
 import scala.language.implicitConversions
 import scala.reflect.ClassTag
 import scala.util.control.NonFatal
-import scala.xml.{Attribute, Elem, Node, Text, Null}
+import scala.xml.{Attribute, Elem, Node, Null, Text}
 
 @PluginType()
 trait WorkspaceProvider extends AnyPlugin {
@@ -146,7 +146,7 @@ trait WorkspaceProvider extends AnyPlugin {
     * Returns an SPARQL endpoint that allows query access to the projects.
     * May return None if the projects are not held as RDF.
     */
-  def sparqlEndpoint: Option[SparqlEndpoint]
+  def sparqlEndpoint: Option[SparqlEndpoint with GraphStoreTrait]
 
   private val externalLoadingErrors: mutable.HashMap[String, Vector[TaskLoadingError]] = new mutable.HashMap[String, Vector[TaskLoadingError]]()
 

silk-core/src/test/scala/org/silkframework/util/IdentifierGeneratorTest.scala

@@ -34,4 +34,9 @@ class IdentifierGeneratorTest extends AnyFlatSpec with Matchers {
     generator.generate("person") mustBe Identifier("person2")
     generator.generate("person1") mustBe Identifier("person3")
   }
+
+  it should "not remove trailing numbers if not needed for generating a unique id" in {
+    val generator = new IdentifierGenerator()
+    generator.generate("name1") mustBe Identifier("name1")
+  }
 }

silk-legacy-ui/package.json

@@ -59,7 +59,7 @@
     "@testing-library/jest-dom": "^5.11.6",
     "@testing-library/react": "^11.1.2",
     "@testing-library/user-event": "^12.2.2",
-    "@types/carbon-components-react": "7.44.1",
+    "@types/carbon-components-react": "7.55.2",
     "@types/codemirror": "0.0.109",
     "@types/enzyme": "^3.10.8",
     "@types/enzyme-adapter-react-16": "^1.0.6",

silk-plugins/silk-plugins-rdf/src/main/scala/org/silkframework/plugins/dataset/rdf/vocab/RdfFilesVocabularyManager.scala

@@ -1,18 +1,18 @@
 package org.silkframework.plugins.dataset.rdf.vocab
 
-import java.util.logging.Logger
-
 import org.apache.jena.query.DatasetFactory
 import org.apache.jena.rdf.model.ModelFactory
 import org.apache.jena.riot.{RDFDataMgr, RDFLanguages}
 import org.silkframework.plugins.dataset.rdf.endpoint.JenaDatasetEndpoint
 import org.silkframework.rule.vocab.{Vocabulary, VocabularyManager}
 import org.silkframework.runtime.activity.UserContext
 import org.silkframework.runtime.plugin.annotations.Plugin
-import org.silkframework.runtime.resource.{FileResource, ResourceNotFoundException}
+import org.silkframework.runtime.resource.{Resource, ResourceNotFoundException}
 import org.silkframework.util.Identifier
 import org.silkframework.workspace.WorkspaceFactory
 
+import java.util.logging.Logger
+
 @Plugin(
   id = "rdfFiles",
   label = "RDF Files",
@@ -31,20 +31,7 @@ case class RdfFilesVocabularyManager() extends VocabularyManager {
       if(vocabularyResource.nonEmpty && vocabularyResource.get.size.nonEmpty &&
           !vocabularyResource.get.size.contains(0L)) { // only consider files
         val resource = vocabularyResource.get
-        // Load into Jena model
-        val model = ModelFactory.createDefaultModel()
-        val inputStream = resource.inputStream
-        RDFDataMgr.read(model, inputStream, RDFLanguages.filenameToLang(resource.name))
-        inputStream.close()
-
-        // Create vocabulary loader
-        val dataset = DatasetFactory.createTxnMem()
-        dataset.addNamedModel(prefix + uri, model)
-        val endpoint = new JenaDatasetEndpoint(dataset)
-        val loader = new VocabularyLoader(endpoint)
-
-        // Load vocabulary
-        loader.retrieveVocabulary(prefix + uri)
+        loadVocabulary(resource, uri)
       } else {
         None
       }
@@ -55,6 +42,27 @@ case class RdfFilesVocabularyManager() extends VocabularyManager {
     }
   }
 
+  /**
+   * Loads a vocabulary from a file.
+   */
+  def loadVocabulary(resource: Resource, uri: String)
+                    (implicit userContext: UserContext): Option[Vocabulary] = {
+    // Load into Jena model
+    val model = ModelFactory.createDefaultModel()
+    val inputStream = resource.inputStream
+    RDFDataMgr.read(model, inputStream, RDFLanguages.filenameToLang(resource.name))
+    inputStream.close()
+
+    // Create vocabulary loader
+    val dataset = DatasetFactory.createTxnMem()
+    dataset.addNamedModel(prefix + uri, model)
+    val endpoint = new JenaDatasetEndpoint(dataset)
+    val loader = new VocabularyLoader(endpoint)
+
+    // Load vocabulary
+    loader.retrieveVocabulary(prefix + uri)
+  }
+
   override def retrieveGlobalVocabularies()(implicit userContext: UserContext): Option[Iterable[String]] = {
     // FIXME: Not clear how to automatically decide which RDF files are global vocabularies without registering them.
     None

silk-plugins/silk-plugins-rdf/src/main/scala/org/silkframework/plugins/dataset/rdf/vocab/RdfVocabularyManager.scala

@@ -1,6 +1,6 @@
 package org.silkframework.plugins.dataset.rdf.vocab
 
-import org.silkframework.dataset.rdf.SparqlEndpoint
+import org.silkframework.dataset.rdf.{GraphStoreTrait, SparqlEndpoint}
 import org.silkframework.rule.vocab.{Vocabulary, VocabularyManager}
 import org.silkframework.runtime.activity.UserContext
 import org.silkframework.runtime.plugin.annotations.Plugin
@@ -20,7 +20,7 @@ case class RdfVocabularyManager() extends VocabularyManager {
     loader.retrieveVocabulary(uri)
   }
 
-  private def workspaceSparqlEndpoint(implicit userContext: UserContext): SparqlEndpoint = {
+  private def workspaceSparqlEndpoint(implicit userContext: UserContext): SparqlEndpoint with GraphStoreTrait = {
     WorkspaceFactory().workspace.provider.sparqlEndpoint match {
       case Some(endpoint) =>
         endpoint

silk-plugins/silk-plugins-rdf/src/main/scala/org/silkframework/plugins/dataset/rdf/vocab/VocabularyLoader.scala

@@ -8,7 +8,7 @@ import org.silkframework.runtime.activity.UserContext
 import scala.collection.immutable.SortedMap
 import scala.collection.mutable
 
-class VocabularyLoader(endpoint: SparqlEndpoint) {
+class VocabularyLoader(endpoint: SparqlEndpoint with GraphStoreTrait) {
   final val languageRanking: IndexedSeq[String] = IndexedSeq("en", "de", "es", "fr", "it", "pt")
 
   def retrieveVocabulary(uri: String)(implicit userContext: UserContext): Option[Vocabulary] = {
@@ -17,7 +17,8 @@ class VocabularyLoader(endpoint: SparqlEndpoint) {
     Some(Vocabulary(
       info = vocabGenericInfo,
       classes = classes.toSeq,
-      properties = retrieveProperties(uri, classes.toSeq)
+      properties = retrieveProperties(uri, classes.toSeq),
+      endpoint = Some(endpoint)
     ))
   }