Incorporate AspectModelBuilder functionality in AspectModelLoader

Creating an AspectModel from a list of AspectModelFiles should be located next
to the other methods that create an AspectModel from various input sources

Author: atextor

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/aspectmodel/AspectModelBuilder.java

@@ -92,7 +92,7 @@ public synchronized void redoChange() {
    }
 
    private void updateAspectModelAfterChange() {
-      final AspectModel updatedModel = AspectModelLoader.buildAspectModelFromFiles( aspectModel.files() );
+      final AspectModel updatedModel = new AspectModelLoader().loadAspectModelFiles( aspectModel.files() );
       aspectModel.setMergedModel( updatedModel.mergedModel() );
       aspectModel.setElements( updatedModel.elements() );
       aspectModel.setFiles( updatedModel.files() );

core/esmf-aspect-meta-model-java/src/main/java/org/eclipse/esmf/aspectmodel/edit/AspectChangeContext.java

@@ -26,15 +26,17 @@
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Deque;
+import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
+import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
 import java.util.function.Supplier;
+import java.util.stream.Collectors;
 import java.util.zip.ZipEntry;
 import java.util.zip.ZipInputStream;
 
-import org.eclipse.esmf.aspectmodel.AspectModelBuilder;
 import org.eclipse.esmf.aspectmodel.AspectModelFile;
 import org.eclipse.esmf.aspectmodel.RdfUtil;
 import org.eclipse.esmf.aspectmodel.resolver.AspectModelFileLoader;
@@ -44,15 +46,22 @@
 import org.eclipse.esmf.aspectmodel.resolver.ResolutionStrategy;
 import org.eclipse.esmf.aspectmodel.resolver.ResolutionStrategySupport;
 import org.eclipse.esmf.aspectmodel.resolver.fs.FlatModelsRoot;
+import org.eclipse.esmf.aspectmodel.resolver.modelfile.DefaultAspectModelFile;
+import org.eclipse.esmf.aspectmodel.resolver.modelfile.MetaModelFile;
 import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
 import org.eclipse.esmf.aspectmodel.urn.ElementType;
 import org.eclipse.esmf.aspectmodel.urn.UrnSyntaxException;
 import org.eclipse.esmf.aspectmodel.versionupdate.MetaModelVersionMigrator;
 import org.eclipse.esmf.metamodel.AspectModel;
+import org.eclipse.esmf.metamodel.ModelElement;
+import org.eclipse.esmf.metamodel.Namespace;
+import org.eclipse.esmf.metamodel.impl.DefaultAspectModel;
+import org.eclipse.esmf.metamodel.impl.DefaultNamespace;
 import org.eclipse.esmf.metamodel.vocabulary.SammNs;
 
 import com.google.common.collect.Streams;
 import org.apache.jena.rdf.model.Model;
+import org.apache.jena.rdf.model.ModelFactory;
 import org.apache.jena.rdf.model.RDFNode;
 import org.apache.jena.rdf.model.Resource;
 import org.apache.jena.rdf.model.Statement;
@@ -132,7 +141,7 @@ public AspectModel load( final Collection<File> files ) {
             .toList();
       final LoaderContext loaderContext = new LoaderContext();
       resolve( migratedFiles, loaderContext );
-      return AspectModelBuilder.buildAspectModelFromFiles( loaderContext.loadedFiles() );
+      return loadAspectModelFiles( loaderContext.loadedFiles() );
    }
 
    /**
@@ -157,7 +166,7 @@ public AspectModel loadUrns( final Collection<AspectModelUrn> urns ) {
          loaderContext.unresolvedUrns().add( inputUrn.toString() );
       }
       resolve( List.of(), loaderContext );
-      return AspectModelBuilder.buildAspectModelFromFiles( loaderContext.loadedFiles() );
+      return loadAspectModelFiles( loaderContext.loadedFiles() );
    }
 
    /**
@@ -172,7 +181,7 @@ public AspectModel load( final InputStream inputStream, final Optional<URI> sour
       final AspectModelFile migratedModel = migrate( rawFile );
       final LoaderContext loaderContext = new LoaderContext();
       resolve( List.of( migratedModel ), loaderContext );
-      return AspectModelBuilder.buildAspectModelFromFiles( loaderContext.loadedFiles() );
+      return loadAspectModelFiles( loaderContext.loadedFiles() );
    }
 
    /**
@@ -247,7 +256,7 @@ private AspectModel loadNamespacePackageFromStream( final InputStream inputStrea
 
       final LoaderContext loaderContext = new LoaderContext();
       resolve( aspectModelFiles, loaderContext );
-      return AspectModelBuilder.buildAspectModelFromFiles( loaderContext.loadedFiles() );
+      return loadAspectModelFiles( loaderContext.loadedFiles() );
    }
 
    private boolean containsFolderInNamespacePackage( final InputStream inputStream ) {
@@ -402,4 +411,92 @@ public boolean containsDefinition( final AspectModelFile aspectModelFile, final
       LOG.debug( "Checking if model contains {}: {}", urn, result );
       return result;
    }
+
+   public AspectModel emptyModel() {
+      return new DefaultAspectModel( new ArrayList<>(), ModelFactory.createDefaultModel(), new ArrayList<>() );
+   }
+
+   public AspectModel loadAspectModelFiles( final Collection<AspectModelFile> inputFiles ) {
+      final Model mergedModel = ModelFactory.createDefaultModel();
+      mergedModel.add( MetaModelFile.metaModelDefinitions() );
+      for ( final AspectModelFile file : inputFiles ) {
+         mergedModel.add( file.sourceModel() );
+      }
+
+      final List<ModelElement> elements = new ArrayList<>();
+      final List<AspectModelFile> files = new ArrayList<>();
+      final Map<AspectModelFile, MetaModelBaseAttributes> namespaceDefinitions = new HashMap<>();
+      for ( final AspectModelFile file : inputFiles ) {
+         final DefaultAspectModelFile aspectModelFile = new DefaultAspectModelFile( file.sourceModel(), file.headerComment(),
+               file.sourceLocation() );
+         files.add( aspectModelFile );
+         final Model model = file.sourceModel();
+         final ModelElementFactory modelElementFactory = new ModelElementFactory( mergedModel, Map.of(), element -> aspectModelFile );
+         final List<ModelElement> fileElements = model.listStatements( null, RDF.type, (RDFNode) null ).toList().stream()
+               .filter( statement -> !statement.getObject().isURIResource() || !statement.getResource().equals( SammNs.SAMM.Namespace() ) )
+               .map( Statement::getSubject )
+               .filter( RDFNode::isURIResource )
+               .map( resource -> mergedModel.createResource( resource.getURI() ) )
+               .map( resource -> modelElementFactory.create( ModelElement.class, resource ) )
+               .toList();
+         aspectModelFile.setElements( fileElements );
+         elements.addAll( fileElements );
+      }
+
+      setNamespaces( files, elements );
+      return new DefaultAspectModel( files, mergedModel, elements );
+   }
+
+   private static void setNamespaces( final Collection<AspectModelFile> files, final Collection<ModelElement> elements ) {
+      final Map<String, List<ModelElement>> elementsGroupedByNamespaceUrn = elements.stream()
+            .filter( element -> !element.isAnonymous() )
+            .collect( Collectors.groupingBy( element -> element.urn().getNamespaceIdentifier() ) );
+      for ( final AspectModelFile file : files ) {
+         final Optional<String> optionalNamespaceUrn =
+               Optional.ofNullable( file.sourceModel().getNsPrefixURI( "" ) )
+                     .map( urnPrefix -> urnPrefix.split( "#" )[0] )
+                     .or( () -> file.elements().stream()
+                           .filter( element -> !element.isAnonymous() )
+                           .map( element -> element.urn().getNamespaceIdentifier() )
+                           .findAny() );
+         if ( optionalNamespaceUrn.isEmpty() ) {
+            continue;
+         }
+
+         final String namespaceUrn = optionalNamespaceUrn.get();
+         MetaModelBaseAttributes namespaceDefinition = null;
+         AspectModelFile fileContainingNamespaceDefinition = null;
+         final List<ModelElement> elementsForUrn = elementsGroupedByNamespaceUrn.get( namespaceUrn );
+         if ( elementsForUrn != null ) {
+            for ( final ModelElement element : elementsForUrn ) {
+               final AspectModelFile elementFile = element.getSourceFile();
+               if ( elementFile.sourceModel().contains( null, RDF.type, SammNs.SAMM.Namespace() ) ) {
+                  final Model model = elementFile.sourceModel();
+                  final ModelElementFactory modelElementFactory = new ModelElementFactory( model, Map.of(), __ -> null );
+                  final Resource namespaceResource = model.listStatements( null, RDF.type, SammNs.SAMM.Namespace() )
+                        .mapWith( Statement::getSubject )
+                        .toList().iterator().next();
+                  namespaceDefinition = modelElementFactory.createBaseAttributes( namespaceResource );
+                  fileContainingNamespaceDefinition = elementFile;
+                  break;
+               }
+            }
+         }
+
+         final Namespace namespace = new DefaultNamespace( namespaceUrn, elementsGroupedByNamespaceUrn.get( namespaceUrn ),
+               Optional.ofNullable( fileContainingNamespaceDefinition ), Optional.ofNullable( namespaceDefinition ) );
+         ( (DefaultAspectModelFile) file ).setNamespace( namespace );
+      }
+   }
+
+   public AspectModel merge( final AspectModel aspectModel1, final AspectModel aspectModel2 ) {
+      final List<AspectModelFile> files = new ArrayList<>( aspectModel1.files() );
+      final Set<URI> locations = aspectModel1.files().stream()
+            .flatMap( f -> f.sourceLocation().stream() )
+            .collect( Collectors.toSet() );
+      for ( final AspectModelFile file : aspectModel2.files() ) {
+         file.sourceLocation().filter( uri -> !locations.contains( uri ) ).ifPresent( uri -> files.add( file ) );
+      }
+      return loadAspectModelFiles( files );
+   }
 }