Increase file size to import and fix error message for wrong prefixes (#50)

Author: michelu89

src/main/java/org/eclipse/esmf/ame/config/ApplicationConfig.java

@@ -38,7 +38,8 @@
 import com.github.marschall.memoryfilesystem.MemoryFileSystemBuilder;
 
 /**
- * Configuration file to return the conversion service of all the characteristic class converters
+ * Configuration class for setting up various application-level beans and configurations.
+ * This class primarily sets up properties, file systems, model paths, and CORS mappings.
  */
 @Configuration
 @ComponentScan( basePackageClasses = ResponseExceptionHandler.class )
@@ -49,13 +50,21 @@ public class ApplicationConfig implements WebMvcConfigurer {
    private final Environment environment;
    private FileSystem importFileSystem;
 
+   /**
+    * Constructs an instance of ApplicationConfig with the provided settings and environment.
+    *
+    * @param applicationSettings The settings of the application.
+    * @param environment The environment the application is running in.
+    */
    public ApplicationConfig( final ApplicationSettings applicationSettings, final Environment environment ) {
       this.applicationSettings = applicationSettings;
       this.environment = environment;
    }
 
    /**
-    * mapping to a registry returns nothing
+    * Configures CORS mappings for the application, allowing specific HTTP methods.
+    *
+    * @param registry the CORS registry.
     */
    @Override
    public void addCorsMappings( final CorsRegistry registry ) {
@@ -64,10 +73,9 @@ public void addCorsMappings( final CorsRegistry registry ) {
    }
 
    /**
-    * FUnction to return AspectModelValidator bean to be managed by spring
-    * controller
+    * Creates a bean of {@link AspectModelValidator} with JavaScript evaluations disabled.
     *
-    * @return AspectModelValidator
+    * @return a new instance of AspectModelValidator.
     */
    @Bean
    public AspectModelValidator getAspectModelValidator() {
@@ -77,6 +85,11 @@ public AspectModelValidator getAspectModelValidator() {
       return new AspectModelValidator();
    }
 
+   /**
+    * Creates and returns an in-memory file system for imports.
+    *
+    * @return a new or existing in-memory file system.
+    */
    @Bean
    public FileSystem importFileSystem() {
       if ( importFileSystem == null ) {
@@ -89,6 +102,11 @@ public FileSystem importFileSystem() {
       return importFileSystem;
    }
 
+   /**
+    * Determines and returns the path for models based on the environment profile.
+    *
+    * @return the absolute path to the models.
+    */
    @Bean
    public String modelPath() {
       if ( environment.acceptsProfiles( Profiles.of( "test" ) ) ) {
@@ -98,6 +116,11 @@ public String modelPath() {
       return ProcessPath.MODELS.getPath().toString();
    }
 
+   /**
+    * Creates a list of model resolver strategies with settings and file systems configured.
+    *
+    * @return a list containing an instance of LocalFolderResolverStrategy.
+    */
    @Bean
    public List<ModelResolverStrategy> modelStrategies() {
       return Collections.singletonList(

src/main/java/org/eclipse/esmf/ame/config/SecurityConfig.java

@@ -19,14 +19,23 @@
 import org.springframework.security.web.SecurityFilterChain;
 
 /**
- * Application Security configuration file to configure HTTPSecurity
+ * Represents the application's security configuration.
+ * This configuration is responsible for setting up the HTTP security rules,
+ * such as request matchers and CSRF settings.
+ *
+ * <p>Typical usage includes disabling CSRF and permitting all requests to certain paths.</p>
  */
 @Configuration
 public class SecurityConfig {
    /**
-    * overridden Function to configure HTTPSecurity
+    * Configures the HTTP security filter chain. This configuration disables CSRF,
+    * permits all requests to paths matching "/**", and requires authentication for
+    * all other requests.
+    *
+    * @param http an {@link HttpSecurity} instance to configure.
+    * @return the configured {@link SecurityFilterChain}.
     *
-    * @throws Exception On input error.
+    * @throws Exception if there's an error configuring the {@link HttpSecurity}.
     */
    @Bean
    public SecurityFilterChain filterChain( final HttpSecurity http ) throws Exception {

src/main/java/org/eclipse/esmf/ame/repository/strategy/LocalFolderResolverStrategy.java

@@ -15,9 +15,7 @@
 
 import java.io.File;
 import java.io.IOException;
-import java.io.InputStream;
 import java.nio.channels.FileChannel;
-import java.nio.charset.Charset;
 import java.nio.charset.StandardCharsets;
 import java.nio.file.FileSystem;
 import java.nio.file.Files;
@@ -278,7 +276,8 @@ private List<AspectModelInformation> getListOfAspectModels( final List<String> f
             final String[] arg = transformToValidModelDirectory( path ).split( ":" );
             final String namespace = arg[0] + ":" + arg[1];
             final String fileName = arg[2];
-            String aspectModel = LocalFolderResolverUtils.readString( importFileSystem.getPath( path ), StandardCharsets.UTF_8 );
+            String aspectModel = LocalFolderResolverUtils.readString( importFileSystem.getPath( path ),
+                  StandardCharsets.UTF_8 );
             return new AspectModelInformation( namespace, fileName, aspectModel );
          } catch ( IOException e ) {
             throw new FileNotFoundException( "Cannot find in-memory file to create package information", e );

src/main/java/org/eclipse/esmf/ame/repository/strategy/utils/LocalFolderResolverUtils.java

@@ -13,21 +13,15 @@
 
 package org.eclipse.esmf.ame.repository.strategy.utils;
 
-import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.Charset;
 import java.nio.file.Files;
 import java.nio.file.Path;
-import java.util.Objects;
 
 import javax.annotation.Nonnull;
 
-import org.apache.commons.io.FileUtils;
-import org.eclipse.esmf.ame.exceptions.FileNotFoundException;
-import org.eclipse.esmf.ame.exceptions.InvalidAspectModelException;
 import org.eclipse.esmf.ame.model.resolver.FolderStructure;
-import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
@@ -82,12 +76,13 @@ public static String buildFilePath( final String namespace, final String fileNam
     * @param path The path to the file to be read.
     * @param charset The character encoding to be used for decoding the file content.
     * @return The content of the file as a string decoded with the specified character encoding.
+    *
     * @throws IOException If an I/O error occurs while reading the file.
     */
-   public static String readString( Path path, Charset charset) throws IOException {
-      try ( InputStream inputStream = Files.newInputStream(path)) {
+   public static String readString( Path path, Charset charset ) throws IOException {
+      try ( InputStream inputStream = Files.newInputStream( path ) ) {
          byte[] bytes = inputStream.readAllBytes();
-         return new String(bytes, charset);
+         return new String( bytes, charset );
       }
    }
 }

src/main/java/org/eclipse/esmf/ame/resolver/strategy/InMemoryStrategy.java

@@ -27,49 +27,54 @@
 
 import org.apache.jena.rdf.model.Model;
 import org.apache.jena.riot.RiotException;
+import org.eclipse.esmf.ame.model.repository.AspectModelInformation;
 import org.eclipse.esmf.ame.repository.strategy.utils.LocalFolderResolverUtils;
 import org.eclipse.esmf.aspectmodel.resolver.AspectModelResolver;
 import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
 
 import io.vavr.control.Try;
+import lombok.Getter;
 
+@Getter
 public class InMemoryStrategy extends ResolutionStrategy {
-   public final FileSystem fileSystem;
+   private final FileSystem fileSystem;
 
-   public InMemoryStrategy( final String aspectModel, final Path processingRootPath, final FileSystem fileSystem )
-           throws RiotException {
-      super( aspectModel, processingRootPath );
+   public InMemoryStrategy( final AspectModelInformation aspectModelInformation, final Path processingRootPath,
+         final FileSystem fileSystem ) throws RiotException {
+      super( aspectModelInformation, processingRootPath );
       this.fileSystem = fileSystem;
    }
 
    protected Try<Model> getModelFromFileSystem( final AspectModelUrn aspectModelUrn, final Path rootPath ) {
       try ( Stream<Path> pathStream = Files.walk( rootPath ) ) {
          final String filePath =
-                 aspectModelUrn.getNamespace() + File.separator + aspectModelUrn.getVersion() + File.separator
-                         + aspectModelUrn.getName() + ".ttl";
+               aspectModelUrn.getNamespace() + File.separator + aspectModelUrn.getVersion() + File.separator
+                     + aspectModelUrn.getName() + ".ttl";
 
          final Path file = fileSystem.getPath( filePath );
 
          if ( Files.exists( file ) ) {
-            return Try.of( () -> loadTurtleFromString( LocalFolderResolverUtils.readString( file, StandardCharsets.UTF_8 ) ) );
+            return Try.of(
+                  () -> loadTurtleFromString( LocalFolderResolverUtils.readString( file, StandardCharsets.UTF_8 ) ) );
          }
 
          LOG.warn( "Looking for {}, but no {}.ttl was found. Inspecting files in {}", aspectModelUrn.getName(),
-                 aspectModelUrn.getName(), filePath );
+               aspectModelUrn.getName(), filePath );
 
-         Optional<Try<Model>> modelWithDefinition = pathStream
-                 .filter( Files::isRegularFile )
-                 .map( Path::toAbsolutePath )
-                 .map( Path::toString )
-                 .map( fileSystem::getPath )
-                 .map( aspectModelPath -> Try.of( () -> loadTurtleFromString( LocalFolderResolverUtils.readString( aspectModelPath, StandardCharsets.UTF_8 ) ) ) )
-                 .filter( tryModel -> tryModel.map(
-                                 model -> AspectModelResolver.containsDefinition( model, aspectModelUrn ) )
-                         .getOrElse( false ) )
-                 .findFirst();
+         Optional<Try<Model>> modelWithDefinition = pathStream.filter( Files::isRegularFile )
+                                                              .map( Path::toAbsolutePath ).map( Path::toString )
+                                                              .map( fileSystem::getPath )
+                                                              .map( aspectModelPath -> Try.of(
+                                                                    () -> loadTurtleFromString(
+                                                                          LocalFolderResolverUtils.readString(
+                                                                                aspectModelPath,
+                                                                                StandardCharsets.UTF_8 ) ) ) ).filter(
+                     tryModel -> tryModel.map(
+                                               model -> AspectModelResolver.containsDefinition( model, aspectModelUrn ) )
+                                         .getOrElse( false ) ).findFirst();
 
          return modelWithDefinition.orElse( Try.failure( new FileNotFoundException(
-                 "No model file containing " + aspectModelUrn + " could be found in directory" ) ) );
+               "No model file containing " + aspectModelUrn + " could be found in directory" ) ) );
       } catch ( IOException exception ) {
          return Try.failure( exception );
       }

src/main/java/org/eclipse/esmf/ame/resolver/strategy/ResolutionStrategy.java

@@ -32,7 +32,9 @@
 import org.apache.jena.riot.RiotException;
 import org.apache.jena.vocabulary.RDF;
 import org.eclipse.esmf.ame.exceptions.FileReadException;
+import org.eclipse.esmf.ame.exceptions.InvalidAspectModelException;
 import org.eclipse.esmf.ame.exceptions.UrnNotFoundException;
+import org.eclipse.esmf.ame.model.repository.AspectModelInformation;
 import org.eclipse.esmf.aspectmodel.resolver.AbstractResolutionStrategy;
 import org.eclipse.esmf.aspectmodel.resolver.services.TurtleLoader;
 import org.eclipse.esmf.aspectmodel.urn.AspectModelUrn;
@@ -45,18 +47,54 @@
 
 import io.vavr.NotImplementedError;
 import io.vavr.control.Try;
+import lombok.Getter;
 
+/**
+ * Represents a resolution strategy for handling aspect models.
+ *
+ * <p>This abstract class provides common methods and behaviors to resolve and load aspect models, and should be
+ * extended to create specific resolution strategies.</p>
+ */
+@Getter
 public abstract class ResolutionStrategy extends AbstractResolutionStrategy {
    private static final Logger LOG = LoggerFactory.getLogger( ResolutionStrategy.class );
 
-   public final Path processingRootPath;
-   public final Model aspectModel;
+   private final Path processingRootPath;
+   private final Model currentAspectModel;
+
+   private final String currentFileName;
 
+   /**
+    * Constructs a new ResolutionStrategy with the given parameters.
+    *
+    * @param aspectModel The aspect model file content as string.
+    * @param processingRootPath The root path where processing should occur.
+    */
    public ResolutionStrategy( final String aspectModel, final Path processingRootPath ) {
       this.processingRootPath = processingRootPath;
-      this.aspectModel = loadTurtleFromString( aspectModel );
+      this.currentFileName = "NEW LOADED FILE";
+      this.currentAspectModel = loadTurtleFromString( aspectModel );
+   }
+
+   /**
+    * Constructs a new ResolutionStrategy with the given parameters.
+    *
+    * @param aspectModelInformation The information about the aspect model.
+    * @param processingRootPath The root path where processing should occur.
+    */
+   public ResolutionStrategy( final AspectModelInformation aspectModelInformation, final Path processingRootPath ) {
+      this.processingRootPath = processingRootPath;
+      this.currentFileName = aspectModelInformation.getFileName();
+      this.currentAspectModel = loadTurtleFromString( aspectModelInformation.getAspectModel() );
    }
 
+   /**
+    * Attempts to apply the given aspect model URN.
+    * <p>The method will resolve the model from the filesystem or fallback to other strategies based on the URN.</p>
+    *
+    * @param aspectModelUrn The aspect model URN to be processed.
+    * @return A try containing the resolved model, or a failure if the model cannot be resolved.
+    */
    @Override
    public Try<Model> apply( final AspectModelUrn aspectModelUrn ) {
       if ( aspectModelUrn == null ) {
@@ -75,19 +113,19 @@ private Try<Model> tryOnSuccess( final AspectModelUrn aspectModelUrn, final Try<
          return modelFromFileSystem;
       }
 
-      return Try.success( aspectModel );
+      return Try.success( currentAspectModel );
    }
 
    private Try<Model> tryOnFailure( final AspectModelUrn aspectModelUrn ) {
-      final StmtIterator stmtIterator = aspectModel.listStatements(
+      final StmtIterator stmtIterator = currentAspectModel.listStatements(
             ResourceFactory.createResource( aspectModelUrn.toString() ), null, (RDFNode) null );
 
       if ( stmtIterator.hasNext() ) {
-         return Try.success( aspectModel );
+         return Try.success( currentAspectModel );
       }
 
-      return Try.failure( new UrnNotFoundException(
-            String.format( "%s cannot be resolved correctly.", aspectModelUrn ), aspectModelUrn ) );
+      return Try.failure( new UrnNotFoundException( String.format( "%s cannot be resolved correctly.", aspectModelUrn ),
+            aspectModelUrn ) );
    }
 
    protected abstract Try<Model> getModelFromFileSystem( AspectModelUrn aspectModelUrn, Path rootPath );
@@ -118,25 +156,45 @@ protected Try<Model> loadTurtleFromFile( final File aspectModel ) {
       }
    }
 
+   /**
+    * Retrieves the aspect model URN for the current aspect model.
+    *
+    * @return The aspect model URN.
+    */
    public AspectModelUrn getAspectModelUrn() {
-      return AspectModelUrn.fromUrn(
-            getEsmfStatements( aspectModel ).orElseThrow(
-                  () -> new NotImplementedError( "AspectModelUrn cannot be found." ) ).next().getSubject().getURI() );
+      return AspectModelUrn.fromUrn( getEsmfStatements( currentAspectModel ).orElseThrow(
+            () -> new InvalidAspectModelException( String.format(
+                  "Unable to find a recognized version of SAMM (with the identifier 'urn:samm:org.eclipse.esmf.samm') in the file: %s.",
+                  this.currentFileName ) ) ).next().getSubject().getURI() );
    }
 
+   /**
+    * Retrieves the ESMF statements for the given aspect model.
+    *
+    * @param aspectModel The aspect model to get statements from.
+    * @return An optional containing the statement iterator if available, or empty otherwise.
+    */
    public static Optional<StmtIterator> getEsmfStatements( final Model aspectModel ) {
       final List<StmtIterator> stmtIterators = new ArrayList<>();
-
       KnownVersion.getVersions()
-                  .forEach( version -> stmtIterators.addAll( getListOfAllSAMMElements( version )
-                        .stream()
-                        .filter( resource -> aspectModel.listStatements( null, RDF.type, resource ).hasNext() )
-                        .map( resource -> aspectModel.listStatements( null, RDF.type, resource ) )
-                        .toList() ) );
-
+                  .forEach( version -> addAllStatementsFromVersion( aspectModel, stmtIterators, version ) );
       return stmtIterators.isEmpty() ? Optional.empty() : stmtIterators.stream().findFirst();
    }
 
+   private static void addAllStatementsFromVersion( final Model aspectModel, final List<StmtIterator> stmtIterators,
+         final KnownVersion version ) {
+      stmtIterators.addAll( getListOfAllSAMMElements( version ).stream().filter(
+                                                                     resource -> aspectModel.listStatements( null, RDF.type, resource ).hasNext() )
+                                                               .map( resource -> aspectModel.listStatements( null,
+                                                                     RDF.type, resource ) ).toList() );
+   }
+
+   /**
+    * Retrieves a list of all SAMM elements for the given known version.
+    *
+    * @param version The known version to get SAMM elements from.
+    * @return A list of resources representing the SAMM elements.
+    */
    private static List<Resource> getListOfAllSAMMElements( final KnownVersion version ) {
       final SAMM samm = new SAMM( version );
       final SAMMC sammc = new SAMMC( version );