Fix model resolution

Author: atextor

core/sds-aspect-model-resolver/src/main/java/io/openmanufacturing/sds/aspectmodel/resolver/AspectModelResolver.java

@@ -2,7 +2,7 @@
  * Copyright (c) 2021 Robert Bosch Manufacturing Solutions GmbH
  *
  * See the AUTHORS file(s) distributed with this work for additional
- * information regarding authorship. 
+ * information regarding authorship.
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
@@ -15,31 +15,31 @@
 
 import java.io.FileNotFoundException;
 import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
 import java.util.Set;
+import java.util.Stack;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 
 import org.apache.jena.rdf.model.Model;
 import org.apache.jena.rdf.model.ModelFactory;
-import org.apache.jena.rdf.model.Resource;
-import org.apache.jena.rdf.model.ResourceFactory;
+import org.apache.jena.rdf.model.RDFNode;
 import org.apache.jena.rdf.model.Statement;
+import org.apache.jena.rdf.model.StmtIterator;
 import org.apache.jena.vocabulary.RDF;
+import org.apache.jena.vocabulary.XSD;
 
-import com.google.common.collect.Sets;
 import com.google.common.collect.Streams;
 
 import io.openmanufacturing.sds.aspectmodel.VersionNumber;
 import io.openmanufacturing.sds.aspectmodel.resolver.services.VersionedModel;
 import io.openmanufacturing.sds.aspectmodel.urn.AspectModelUrn;
-import io.openmanufacturing.sds.aspectmodel.urn.UrnSyntaxException;
+import io.openmanufacturing.sds.aspectmodel.urn.ElementType;
 import io.openmanufacturing.sds.aspectmodel.versionupdate.MigratorFactory;
 import io.openmanufacturing.sds.aspectmodel.versionupdate.MigratorService;
 import io.openmanufacturing.sds.aspectmodel.versionupdate.MigratorServiceLoader;
-import io.vavr.Tuple;
-import io.vavr.Tuple2;
-import io.vavr.Value;
 import io.vavr.control.Option;
 import io.vavr.control.Try;
 
@@ -57,7 +57,7 @@ public class AspectModelResolver {
     * @param model The RDF model
     * @return The set of URNs
     */
-   public static Set<AspectModelUrn> getAllUrnsInModel( final Model model ) {
+   public static Set<String> getAllUrnsInModel( final Model model ) {
       return Streams.stream( model.listStatements().mapWith( statement -> {
          final Stream<String> subjectUri = statement.getSubject().isURIResource() ?
                Stream.of( statement.getSubject().getURI() ) : Stream.empty();
@@ -66,26 +66,10 @@ public static Set<AspectModelUrn> getAllUrnsInModel( final Model model ) {
                Stream.of( statement.getObject().asResource().getURI() ) : Stream.empty();
 
          return Stream.of( subjectUri, propertyUri, objectUri )
-                      .flatMap( Function.identity() )
-                      .map( AspectModelResolver::getAspectModelUrn )
-                      .flatMap( Value::toJavaStream );
+               .flatMap( Function.identity() );
       } ) ).flatMap( Function.identity() ).collect( Collectors.toSet() );
    }
 
-   /**
-    * Parses an Aspect (meta) model URN into an {@link AspectModelUrn}
-    *
-    * @param uri The Aspect (meta) model URN
-    * @return The {@link AspectModelUrn} if parsing succeeds, an {@link UrnSyntaxException} otherwise
-    */
-   private static Try<AspectModelUrn> getAspectModelUrn( final String uri ) {
-      try {
-         return Try.success( AspectModelUrn.fromUrn( uri ) );
-      } catch ( final UrnSyntaxException exception ) {
-         return Try.failure( exception );
-      }
-   }
-
    /**
     * Method to resolve a given {@link AspectModelUrn} using a suitable {@link ResolutionStrategy}.
     * This creates the closure (merged model) of all referenced models and the corresponding meta model.
@@ -95,10 +79,7 @@ private static Try<AspectModelUrn> getAspectModelUrn( final String uri ) {
     * @return The resolved model on success
     */
    public Try<VersionedModel> resolveAspectModel( final ResolutionStrategy resolver, final AspectModelUrn input ) {
-
-      final Tuple2<Try<Model>, Set<AspectModelUrn>> resolutionResult =
-            resolve( ModelFactory.createDefaultModel(), input, resolver, Set.of() );
-      final Try<Model> mergedModel = resolutionResult._1();
+      final Try<Model> mergedModel = resolve( input.toString(), resolver );
 
       if ( mergedModel.isFailure() ) {
          if ( mergedModel.getCause() instanceof FileNotFoundException ) {
@@ -112,7 +93,7 @@ public Try<VersionedModel> resolveAspectModel( final ResolutionStrategy resolver
 
       final Set<VersionNumber> usedMetaModelVersions =
             mergedModel.map( resourceResolver::getUsedMetaModelVersions )
-                       .getOrElse( Collections.emptySet() );
+                  .getOrElse( Collections.emptySet() );
 
       if ( usedMetaModelVersions.isEmpty() ) {
          return Try.failure( new ModelResolutionException( "Could not determine used meta model version" ) );
@@ -121,7 +102,7 @@ public Try<VersionedModel> resolveAspectModel( final ResolutionStrategy resolver
       if ( usedMetaModelVersions.size() == 1 && migratorService.getMigratorFactory().isEmpty() ) {
          return mergedModel.flatMap( model ->
                migratorService.getSdsMigratorFactory().createAspectMetaModelResourceResolver()
-                              .mergeMetaModelIntoRawModel( model, usedMetaModelVersions.iterator().next() ) );
+                     .mergeMetaModelIntoRawModel( model, usedMetaModelVersions.iterator().next() ) );
       }
 
       final Try<VersionNumber> oldestVersion =
@@ -130,85 +111,95 @@ public Try<VersionedModel> resolveAspectModel( final ResolutionStrategy resolver
       return mergedModel.flatMap( model ->
             oldestVersion.flatMap( oldest ->
                   migratorService.getSdsMigratorFactory()
-                                 .createAspectMetaModelResourceResolver()
-                                 .mergeMetaModelIntoRawModel( model, oldest )
-                                 .orElse( () -> migratorService.getMigratorFactory()
-                                                               .map( MigratorFactory::createAspectMetaModelResourceResolver )
-                                                               .map( Try::success )
-                                                               .orElseThrow()
-                                                               .flatMap( metaResolver -> metaResolver.mergeMetaModelIntoRawModel( model, oldest ) ) )
-                                 .flatMap( migratorService::updateMetaModelVersion ) ) );
+                        .createAspectMetaModelResourceResolver()
+                        .mergeMetaModelIntoRawModel( model, oldest )
+                        .orElse( () -> migratorService.getMigratorFactory()
+                              .map( MigratorFactory::createAspectMetaModelResourceResolver )
+                              .map( Try::success )
+                              .orElseThrow()
+                              .flatMap( metaResolver -> metaResolver.mergeMetaModelIntoRawModel( model, oldest ) ) )
+                        .flatMap( migratorService::updateMetaModelVersion ) ) );
    }
 
    /**
-    * Checks if a given model contains the definition of a model element. This is determined by checking whether the
-    * statement "modelElement rdf:type *" or "modelElement bamm:refines *" exists.
+    * Checks if a given model contains the definition of a model element.
     *
     * @param model the model
     * @param urn the URN of the model element
     * @return true if the model contains the definition of the model element
     */
    public static boolean containsDefinition( final Model model, final AspectModelUrn urn ) {
-      return Streams.stream( model.listStatements() )
-                    .anyMatch( statement -> isBammElementDefinition( urn, statement ) );
-   }
-
-   private static boolean isBammElementDefinition( final AspectModelUrn urn, final Statement statement ) {
-      final Resource resource = ResourceFactory.createResource( urn.getUrn().toString() );
-      final String bammRefinesRegex = ".*\\bmeta-model:\\b.*\\b#refines";
-      return resource.equals( statement.getSubject() ) &&
-            (RDF.type.equals( statement.getPredicate() ) ||
-                  statement.getPredicate().toString().matches( bammRefinesRegex ));
+      return model.contains( model.createResource( urn.toString() ), RDF.type, (RDFNode) null );
    }
 
-   private Tuple2<Try<Model>, Set<AspectModelUrn>> resolve( final Model targetModel,
-         final AspectModelUrn urn,
-         final ResolutionStrategy resolver, final Set<AspectModelUrn> resolvedUrns ) {
+   private Try<Model> resolve( final String urn, final ResolutionStrategy resolutionStrategy ) {
+      final Model result = ModelFactory.createDefaultModel();
+      final Stack<String> unresolvedUrns = new Stack<>();
+      final Set<Model> mergedModels = new HashSet<>();
+      unresolvedUrns.push( urn );
+
+      while ( !unresolvedUrns.isEmpty() ) {
+         final String urnToResolve = unresolvedUrns.pop();
+         final Try<Model> resolvedModel = getModelForUrn( urnToResolve, resolutionStrategy );
+         if ( resolvedModel.isFailure() ) {
+            return resolvedModel;
+         }
+         final Model model = resolvedModel.get();
 
-      if ( resolvedUrns.contains( urn ) ) {
-         return Tuple.of( Try.success( targetModel ), resolvedUrns );
+         // Merge the resolved model into the target if it was not already merged before
+         // (because the model contains more than one definition)
+         if ( !mergedModels.contains( model ) ) {
+            mergeModels( result, model );
+            mergedModels.add( model );
+         }
+         for ( final String element : getAllUrnsInModel( model ) ) {
+            if ( !result.contains( model.createResource( element ), RDF.type, (RDFNode) null )
+                  && !unresolvedUrns.contains( element ) ) {
+               unresolvedUrns.push( element );
+            }
+         }
       }
 
-      final Set<AspectModelUrn> updatedResolvedUrns = Sets.union( resolvedUrns, Set.of( urn ) );
-      if ( containsDefinition( targetModel, urn ) ) {
-         return Tuple.of( Try.success( targetModel ), updatedResolvedUrns );
-      }
+      return Try.success( result );
+   }
 
-      final Try<Model> loadedModel = resolver.apply( urn );
-      if ( loadedModel.isFailure() ) {
-         return Tuple.of( loadedModel, updatedResolvedUrns );
+   private final Model EMPTY_MODEL = ModelFactory.createDefaultModel();
+
+   private Try<Model> getModelForUrn( final String urn, final ResolutionStrategy resolutionStrategy ) {
+      if ( urn.startsWith( RDF.getURI() ) || urn.startsWith( XSD.getURI() ) ) {
+         return Try.success( EMPTY_MODEL );
       }
 
-      addModelWithoutOverwritingEmptyPrefix( targetModel, loadedModel.get() );
-      return getAllUrnsInModel( loadedModel.get() )
-            .stream()
-            .filter( modelUrn -> !modelUrn.isBammUrn() )
-            .reduce( Tuple.of( Try.success( targetModel ), updatedResolvedUrns ),
-                  (( tuple, aspectModelUrn ) ->
-                        resolve( targetModel, aspectModelUrn, resolver, updatedResolvedUrns )),
-                  ( tuple, tuple2 ) -> {
-                     final Try<Model> mergedModels = tuple._1().flatMap( model ->
-                           tuple2._1().map( model2 -> addModelWithoutOverwritingEmptyPrefix( model, model2 ) ) );
-                     final Set<AspectModelUrn> mergedSets = Sets.union( tuple._2(), tuple2._2() );
-                     return Tuple.of( mergedModels, mergedSets );
-                  } );
+      final AspectModelUrn aspectModelUrn = AspectModelUrn.fromUrn( urn );
+      if ( aspectModelUrn.getElementType() != ElementType.NONE ) {
+         return Try.success( EMPTY_MODEL );
+      }
+      return resolutionStrategy.apply( aspectModelUrn ).flatMap( model -> {
+         if ( !model.contains( model.createResource( urn ), RDF.type, (RDFNode) null ) ) {
+            return Try.failure( new ModelResolutionException( "Resolution strategy returned a model which does contain element definition for " + urn ) );
+         }
+         return Try.success( model );
+      } );
    }
 
-   private Model addModelWithoutOverwritingEmptyPrefix( final Model target, final Model modelToAdd ) {
-      if ( !target.getNsPrefixMap().containsKey( "" ) && modelToAdd.getNsPrefixMap().containsKey( "" ) ) {
-         target.setNsPrefix( "", modelToAdd.getNsPrefixURI( "" ) );
+   private void mergeModels( final Model target, final Model other ) {
+      for ( final Map.Entry<String, String> prefixEntry : other.getNsPrefixMap().entrySet() ) {
+         if ( !target.getNsPrefixMap().containsKey( prefixEntry.getKey() ) ) {
+            target.setNsPrefix( prefixEntry.getKey(), prefixEntry.getValue() );
+         }
       }
 
-      modelToAdd.getNsPrefixMap().entrySet().stream().filter( entry -> !"".equals( entry.getKey() ) )
-                .forEach( entry -> target.setNsPrefix( entry.getKey(), entry.getValue() ) );
-
-      migratorService.getMigratorFactory().map( MigratorFactory::createAspectMetaModelResourceResolver ).stream()
-                     .flatMap(
-                           aspectMetaModelResourceResolver -> aspectMetaModelResourceResolver
-                                 .listAspectStatements( modelToAdd, target ) ).forEach( target::add );
+      for ( final StmtIterator it = other.listStatements(); it.hasNext(); ) {
+         final Statement statement = it.next();
 
-      migratorService.getSdsMigratorFactory().createAspectMetaModelResourceResolver()
-                     .listAspectStatements( modelToAdd, target ).forEach( target::add );
-      return target;
+         if ( target.contains( statement.getSubject(), statement.getPredicate(), (RDFNode) null ) ) {
+            // Only add the assertion that is already present in the target model if the value is a language string
+            if ( statement.getObject().isLiteral() && !statement.getLiteral().getLanguage().isEmpty() ) {
+               target.add( statement );
+            }
+         } else {
+            target.add( statement );
+         }
+      }
    }
 }